<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html lang="en">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>LCOV - coverage_clean.info - 13/bits/unordered_map.h</title>
  <link rel="stylesheet" type="text/css" href="../../gcov.css">
</head>

<body>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="title">LCOV - code coverage report</td></tr>
            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>

            <tr>
              <td width="100%">
                <table cellpadding=1 border=0 width="100%">
          <tr>
            <td width="10%" class="headerItem">Current view:</td>
            <td width="10%" class="headerValue"><a href="../../index.html">top level</a> - <a href="index.html">13/bits</a> - unordered_map.h<span style="font-size: 80%;"> (source / <a href="unordered_map.h.func-c.html">functions</a>)</span></td>
            <td width="5%"></td>
            <td width="5%"></td>
            <td width="5%" class="headerCovTableHead">Coverage</td>
            <td width="5%" class="headerCovTableHead" title="Covered + Uncovered code">Total</td>
            <td width="5%" class="headerCovTableHead" title="Exercised code only">Hit</td>
          </tr>
          <tr>
            <td class="headerItem">Test:</td>
            <td class="headerValue">coverage_clean.info</td>
            <td></td>
            <td class="headerItem">Lines:</td>
            <td class="headerCovTableEntryLo">53.8&nbsp;%</td>
            <td class="headerCovTableEntry">13</td>
            <td class="headerCovTableEntry">7</td>
          </tr>
          <tr>
            <td class="headerItem">Test Date:</td>
            <td class="headerValue">2025-11-25 04:45:29</td>
            <td></td>
            <td class="headerItem">Functions:</td>
            <td class="headerCovTableEntryLo">57.1&nbsp;%</td>
            <td class="headerCovTableEntry">7</td>
            <td class="headerCovTableEntry">4</td>
          </tr>
                  <tr><td><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
                </table>
              </td>
            </tr>

            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
          </table>

          <table cellpadding=0 cellspacing=0 border=0>
            <tr>
              <td><br></td>
            </tr>
            <tr>
              <td>
<pre class="sourceHeading">            Line data    Source code</pre>
<pre class="source">
<span id="L1"><span class="lineNum">       1</span>              : // unordered_map implementation -*- C++ -*-</span>
<span id="L2"><span class="lineNum">       2</span>              : </span>
<span id="L3"><span class="lineNum">       3</span>              : // Copyright (C) 2010-2023 Free Software Foundation, Inc.</span>
<span id="L4"><span class="lineNum">       4</span>              : //</span>
<span id="L5"><span class="lineNum">       5</span>              : // This file is part of the GNU ISO C++ Library.  This library is free</span>
<span id="L6"><span class="lineNum">       6</span>              : // software; you can redistribute it and/or modify it under the</span>
<span id="L7"><span class="lineNum">       7</span>              : // terms of the GNU General Public License as published by the</span>
<span id="L8"><span class="lineNum">       8</span>              : // Free Software Foundation; either version 3, or (at your option)</span>
<span id="L9"><span class="lineNum">       9</span>              : // any later version.</span>
<span id="L10"><span class="lineNum">      10</span>              : </span>
<span id="L11"><span class="lineNum">      11</span>              : // This library is distributed in the hope that it will be useful,</span>
<span id="L12"><span class="lineNum">      12</span>              : // but WITHOUT ANY WARRANTY; without even the implied warranty of</span>
<span id="L13"><span class="lineNum">      13</span>              : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the</span>
<span id="L14"><span class="lineNum">      14</span>              : // GNU General Public License for more details.</span>
<span id="L15"><span class="lineNum">      15</span>              : </span>
<span id="L16"><span class="lineNum">      16</span>              : // Under Section 7 of GPL version 3, you are granted additional</span>
<span id="L17"><span class="lineNum">      17</span>              : // permissions described in the GCC Runtime Library Exception, version</span>
<span id="L18"><span class="lineNum">      18</span>              : // 3.1, as published by the Free Software Foundation.</span>
<span id="L19"><span class="lineNum">      19</span>              : </span>
<span id="L20"><span class="lineNum">      20</span>              : // You should have received a copy of the GNU General Public License and</span>
<span id="L21"><span class="lineNum">      21</span>              : // a copy of the GCC Runtime Library Exception along with this program;</span>
<span id="L22"><span class="lineNum">      22</span>              : // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see</span>
<span id="L23"><span class="lineNum">      23</span>              : // &lt;http://www.gnu.org/licenses/&gt;.</span>
<span id="L24"><span class="lineNum">      24</span>              : </span>
<span id="L25"><span class="lineNum">      25</span>              : /** @file bits/unordered_map.h</span>
<span id="L26"><span class="lineNum">      26</span>              :  *  This is an internal header file, included by other library headers.</span>
<span id="L27"><span class="lineNum">      27</span>              :  *  Do not attempt to use it directly. @headername{unordered_map}</span>
<span id="L28"><span class="lineNum">      28</span>              :  */</span>
<span id="L29"><span class="lineNum">      29</span>              : </span>
<span id="L30"><span class="lineNum">      30</span>              : #ifndef _UNORDERED_MAP_H</span>
<span id="L31"><span class="lineNum">      31</span>              : #define _UNORDERED_MAP_H</span>
<span id="L32"><span class="lineNum">      32</span>              : </span>
<span id="L33"><span class="lineNum">      33</span>              : #include &lt;bits/hashtable.h&gt;</span>
<span id="L34"><span class="lineNum">      34</span>              : #include &lt;bits/allocator.h&gt;</span>
<span id="L35"><span class="lineNum">      35</span>              : #include &lt;bits/functional_hash.h&gt; // hash</span>
<span id="L36"><span class="lineNum">      36</span>              : #include &lt;bits/stl_function.h&gt;    // equal_to</span>
<span id="L37"><span class="lineNum">      37</span>              : </span>
<span id="L38"><span class="lineNum">      38</span>              : namespace std _GLIBCXX_VISIBILITY(default)</span>
<span id="L39"><span class="lineNum">      39</span>              : {</span>
<span id="L40"><span class="lineNum">      40</span>              : _GLIBCXX_BEGIN_NAMESPACE_VERSION</span>
<span id="L41"><span class="lineNum">      41</span>              : _GLIBCXX_BEGIN_NAMESPACE_CONTAINER</span>
<span id="L42"><span class="lineNum">      42</span>              : </span>
<span id="L43"><span class="lineNum">      43</span>              :   /// Base types for unordered_map.</span>
<span id="L44"><span class="lineNum">      44</span>              :   template&lt;bool _Cache&gt;</span>
<span id="L45"><span class="lineNum">      45</span>              :     using __umap_traits = __detail::_Hashtable_traits&lt;_Cache, false, true&gt;;</span>
<span id="L46"><span class="lineNum">      46</span>              : </span>
<span id="L47"><span class="lineNum">      47</span>              :   template&lt;typename _Key,</span>
<span id="L48"><span class="lineNum">      48</span>              :            typename _Tp,</span>
<span id="L49"><span class="lineNum">      49</span>              :            typename _Hash = hash&lt;_Key&gt;,</span>
<span id="L50"><span class="lineNum">      50</span>              :            typename _Pred = std::equal_to&lt;_Key&gt;,</span>
<span id="L51"><span class="lineNum">      51</span>              :            typename _Alloc = std::allocator&lt;std::pair&lt;const _Key, _Tp&gt; &gt;,</span>
<span id="L52"><span class="lineNum">      52</span>              :            typename _Tr = __umap_traits&lt;__cache_default&lt;_Key, _Hash&gt;::value&gt;&gt;</span>
<span id="L53"><span class="lineNum">      53</span>              :     using __umap_hashtable = _Hashtable&lt;_Key, std::pair&lt;const _Key, _Tp&gt;,</span>
<span id="L54"><span class="lineNum">      54</span>              :                                         _Alloc, __detail::_Select1st,</span>
<span id="L55"><span class="lineNum">      55</span>              :                                         _Pred, _Hash,</span>
<span id="L56"><span class="lineNum">      56</span>              :                                         __detail::_Mod_range_hashing,</span>
<span id="L57"><span class="lineNum">      57</span>              :                                         __detail::_Default_ranged_hash,</span>
<span id="L58"><span class="lineNum">      58</span>              :                                         __detail::_Prime_rehash_policy, _Tr&gt;;</span>
<span id="L59"><span class="lineNum">      59</span>              : </span>
<span id="L60"><span class="lineNum">      60</span>              :   /// Base types for unordered_multimap.</span>
<span id="L61"><span class="lineNum">      61</span>              :   template&lt;bool _Cache&gt;</span>
<span id="L62"><span class="lineNum">      62</span>              :     using __ummap_traits = __detail::_Hashtable_traits&lt;_Cache, false, false&gt;;</span>
<span id="L63"><span class="lineNum">      63</span>              : </span>
<span id="L64"><span class="lineNum">      64</span>              :   template&lt;typename _Key,</span>
<span id="L65"><span class="lineNum">      65</span>              :            typename _Tp,</span>
<span id="L66"><span class="lineNum">      66</span>              :            typename _Hash = hash&lt;_Key&gt;,</span>
<span id="L67"><span class="lineNum">      67</span>              :            typename _Pred = std::equal_to&lt;_Key&gt;,</span>
<span id="L68"><span class="lineNum">      68</span>              :            typename _Alloc = std::allocator&lt;std::pair&lt;const _Key, _Tp&gt; &gt;,</span>
<span id="L69"><span class="lineNum">      69</span>              :            typename _Tr = __ummap_traits&lt;__cache_default&lt;_Key, _Hash&gt;::value&gt;&gt;</span>
<span id="L70"><span class="lineNum">      70</span>              :     using __ummap_hashtable = _Hashtable&lt;_Key, std::pair&lt;const _Key, _Tp&gt;,</span>
<span id="L71"><span class="lineNum">      71</span>              :                                          _Alloc, __detail::_Select1st,</span>
<span id="L72"><span class="lineNum">      72</span>              :                                          _Pred, _Hash,</span>
<span id="L73"><span class="lineNum">      73</span>              :                                          __detail::_Mod_range_hashing,</span>
<span id="L74"><span class="lineNum">      74</span>              :                                          __detail::_Default_ranged_hash,</span>
<span id="L75"><span class="lineNum">      75</span>              :                                          __detail::_Prime_rehash_policy, _Tr&gt;;</span>
<span id="L76"><span class="lineNum">      76</span>              : </span>
<span id="L77"><span class="lineNum">      77</span>              :   template&lt;class _Key, class _Tp, class _Hash, class _Pred, class _Alloc&gt;</span>
<span id="L78"><span class="lineNum">      78</span>              :     class unordered_multimap;</span>
<span id="L79"><span class="lineNum">      79</span>              : </span>
<span id="L80"><span class="lineNum">      80</span>              :   /**</span>
<span id="L81"><span class="lineNum">      81</span>              :    *  @brief A standard container composed of unique keys (containing</span>
<span id="L82"><span class="lineNum">      82</span>              :    *  at most one of each key value) that associates values of another type</span>
<span id="L83"><span class="lineNum">      83</span>              :    *  with the keys.</span>
<span id="L84"><span class="lineNum">      84</span>              :    *</span>
<span id="L85"><span class="lineNum">      85</span>              :    *  @ingroup unordered_associative_containers</span>
<span id="L86"><span class="lineNum">      86</span>              :    *  @headerfile unordered_map</span>
<span id="L87"><span class="lineNum">      87</span>              :    *  @since C++11</span>
<span id="L88"><span class="lineNum">      88</span>              :    *</span>
<span id="L89"><span class="lineNum">      89</span>              :    *  @tparam  _Key    Type of key objects.</span>
<span id="L90"><span class="lineNum">      90</span>              :    *  @tparam  _Tp     Type of mapped objects.</span>
<span id="L91"><span class="lineNum">      91</span>              :    *  @tparam  _Hash   Hashing function object type, defaults to hash&lt;_Value&gt;.</span>
<span id="L92"><span class="lineNum">      92</span>              :    *  @tparam  _Pred   Predicate function object type, defaults</span>
<span id="L93"><span class="lineNum">      93</span>              :    *                   to equal_to&lt;_Value&gt;.</span>
<span id="L94"><span class="lineNum">      94</span>              :    *  @tparam  _Alloc  Allocator type, defaults to </span>
<span id="L95"><span class="lineNum">      95</span>              :    *                   std::allocator&lt;std::pair&lt;const _Key, _Tp&gt;&gt;.</span>
<span id="L96"><span class="lineNum">      96</span>              :    *</span>
<span id="L97"><span class="lineNum">      97</span>              :    *  Meets the requirements of a &lt;a href=&quot;tables.html#65&quot;&gt;container&lt;/a&gt;, and</span>
<span id="L98"><span class="lineNum">      98</span>              :    *  &lt;a href=&quot;tables.html#xx&quot;&gt;unordered associative container&lt;/a&gt;</span>
<span id="L99"><span class="lineNum">      99</span>              :    *</span>
<span id="L100"><span class="lineNum">     100</span>              :    * The resulting value type of the container is std::pair&lt;const _Key, _Tp&gt;.</span>
<span id="L101"><span class="lineNum">     101</span>              :    *</span>
<span id="L102"><span class="lineNum">     102</span>              :    *  Base is _Hashtable, dispatched at compile time via template</span>
<span id="L103"><span class="lineNum">     103</span>              :    *  alias __umap_hashtable.</span>
<span id="L104"><span class="lineNum">     104</span>              :    */</span>
<span id="L105"><span class="lineNum">     105</span>              :   template&lt;typename _Key, typename _Tp,</span>
<span id="L106"><span class="lineNum">     106</span>              :            typename _Hash = hash&lt;_Key&gt;,</span>
<span id="L107"><span class="lineNum">     107</span>              :            typename _Pred = equal_to&lt;_Key&gt;,</span>
<span id="L108"><span class="lineNum">     108</span>              :            typename _Alloc = allocator&lt;std::pair&lt;const _Key, _Tp&gt;&gt;&gt;</span>
<span id="L109"><span class="lineNum">     109</span>              :     class unordered_map</span>
<span id="L110"><span class="lineNum">     110</span>              :     {</span>
<span id="L111"><span class="lineNum">     111</span>              :       typedef __umap_hashtable&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;  _Hashtable;</span>
<span id="L112"><span class="lineNum">     112</span>              :       _Hashtable _M_h;</span>
<span id="L113"><span class="lineNum">     113</span>              : </span>
<span id="L114"><span class="lineNum">     114</span>              :     public:</span>
<span id="L115"><span class="lineNum">     115</span>              :       // typedefs:</span>
<span id="L116"><span class="lineNum">     116</span>              :       ///@{</span>
<span id="L117"><span class="lineNum">     117</span>              :       /// Public typedefs.</span>
<span id="L118"><span class="lineNum">     118</span>              :       typedef typename _Hashtable::key_type     key_type;</span>
<span id="L119"><span class="lineNum">     119</span>              :       typedef typename _Hashtable::value_type   value_type;</span>
<span id="L120"><span class="lineNum">     120</span>              :       typedef typename _Hashtable::mapped_type  mapped_type;</span>
<span id="L121"><span class="lineNum">     121</span>              :       typedef typename _Hashtable::hasher       hasher;</span>
<span id="L122"><span class="lineNum">     122</span>              :       typedef typename _Hashtable::key_equal    key_equal;</span>
<span id="L123"><span class="lineNum">     123</span>              :       typedef typename _Hashtable::allocator_type allocator_type;</span>
<span id="L124"><span class="lineNum">     124</span>              :       ///@}</span>
<span id="L125"><span class="lineNum">     125</span>              : </span>
<span id="L126"><span class="lineNum">     126</span>              :       ///@{</span>
<span id="L127"><span class="lineNum">     127</span>              :       ///  Iterator-related typedefs.</span>
<span id="L128"><span class="lineNum">     128</span>              :       typedef typename _Hashtable::pointer              pointer;</span>
<span id="L129"><span class="lineNum">     129</span>              :       typedef typename _Hashtable::const_pointer        const_pointer;</span>
<span id="L130"><span class="lineNum">     130</span>              :       typedef typename _Hashtable::reference            reference;</span>
<span id="L131"><span class="lineNum">     131</span>              :       typedef typename _Hashtable::const_reference      const_reference;</span>
<span id="L132"><span class="lineNum">     132</span>              :       typedef typename _Hashtable::iterator             iterator;</span>
<span id="L133"><span class="lineNum">     133</span>              :       typedef typename _Hashtable::const_iterator       const_iterator;</span>
<span id="L134"><span class="lineNum">     134</span>              :       typedef typename _Hashtable::local_iterator       local_iterator;</span>
<span id="L135"><span class="lineNum">     135</span>              :       typedef typename _Hashtable::const_local_iterator const_local_iterator;</span>
<span id="L136"><span class="lineNum">     136</span>              :       typedef typename _Hashtable::size_type            size_type;</span>
<span id="L137"><span class="lineNum">     137</span>              :       typedef typename _Hashtable::difference_type      difference_type;</span>
<span id="L138"><span class="lineNum">     138</span>              :       ///@}</span>
<span id="L139"><span class="lineNum">     139</span>              : </span>
<span id="L140"><span class="lineNum">     140</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L141"><span class="lineNum">     141</span>              :       using node_type = typename _Hashtable::node_type;</span>
<span id="L142"><span class="lineNum">     142</span>              :       using insert_return_type = typename _Hashtable::insert_return_type;</span>
<span id="L143"><span class="lineNum">     143</span>              : #endif</span>
<span id="L144"><span class="lineNum">     144</span>              : </span>
<span id="L145"><span class="lineNum">     145</span>              :       //construct/destroy/copy</span>
<span id="L146"><span class="lineNum">     146</span>              : </span>
<span id="L147"><span class="lineNum">     147</span>              :       /// Default constructor.</span>
<span id="L148"><span class="lineNum">     148</span> <span class="tlaGNC tlaBgGNC">           2 :       unordered_map() = default;</span></span>
<span id="L149"><span class="lineNum">     149</span>              : </span>
<span id="L150"><span class="lineNum">     150</span>              :       /**</span>
<span id="L151"><span class="lineNum">     151</span>              :        *  @brief  Default constructor creates no elements.</span>
<span id="L152"><span class="lineNum">     152</span>              :        *  @param __n  Minimal initial number of buckets.</span>
<span id="L153"><span class="lineNum">     153</span>              :        *  @param __hf  A hash functor.</span>
<span id="L154"><span class="lineNum">     154</span>              :        *  @param __eql  A key equality functor.</span>
<span id="L155"><span class="lineNum">     155</span>              :        *  @param __a  An allocator object.</span>
<span id="L156"><span class="lineNum">     156</span>              :        */</span>
<span id="L157"><span class="lineNum">     157</span>              :       explicit</span>
<span id="L158"><span class="lineNum">     158</span>              :       unordered_map(size_type __n,</span>
<span id="L159"><span class="lineNum">     159</span>              :                     const hasher&amp; __hf = hasher(),</span>
<span id="L160"><span class="lineNum">     160</span>              :                     const key_equal&amp; __eql = key_equal(),</span>
<span id="L161"><span class="lineNum">     161</span>              :                     const allocator_type&amp; __a = allocator_type())</span>
<span id="L162"><span class="lineNum">     162</span>              :       : _M_h(__n, __hf, __eql, __a)</span>
<span id="L163"><span class="lineNum">     163</span>              :       { }</span>
<span id="L164"><span class="lineNum">     164</span>              : </span>
<span id="L165"><span class="lineNum">     165</span>              :       /**</span>
<span id="L166"><span class="lineNum">     166</span>              :        *  @brief  Builds an %unordered_map from a range.</span>
<span id="L167"><span class="lineNum">     167</span>              :        *  @param  __first  An input iterator.</span>
<span id="L168"><span class="lineNum">     168</span>              :        *  @param  __last  An input iterator.</span>
<span id="L169"><span class="lineNum">     169</span>              :        *  @param __n  Minimal initial number of buckets.</span>
<span id="L170"><span class="lineNum">     170</span>              :        *  @param __hf  A hash functor.</span>
<span id="L171"><span class="lineNum">     171</span>              :        *  @param __eql  A key equality functor.</span>
<span id="L172"><span class="lineNum">     172</span>              :        *  @param __a  An allocator object.</span>
<span id="L173"><span class="lineNum">     173</span>              :        *</span>
<span id="L174"><span class="lineNum">     174</span>              :        *  Create an %unordered_map consisting of copies of the elements from</span>
<span id="L175"><span class="lineNum">     175</span>              :        *  [__first,__last).  This is linear in N (where N is</span>
<span id="L176"><span class="lineNum">     176</span>              :        *  distance(__first,__last)).</span>
<span id="L177"><span class="lineNum">     177</span>              :        */</span>
<span id="L178"><span class="lineNum">     178</span>              :       template&lt;typename _InputIterator&gt;</span>
<span id="L179"><span class="lineNum">     179</span>              :         unordered_map(_InputIterator __first, _InputIterator __last,</span>
<span id="L180"><span class="lineNum">     180</span>              :                       size_type __n = 0,</span>
<span id="L181"><span class="lineNum">     181</span>              :                       const hasher&amp; __hf = hasher(),</span>
<span id="L182"><span class="lineNum">     182</span>              :                       const key_equal&amp; __eql = key_equal(),</span>
<span id="L183"><span class="lineNum">     183</span>              :                       const allocator_type&amp; __a = allocator_type())</span>
<span id="L184"><span class="lineNum">     184</span>              :         : _M_h(__first, __last, __n, __hf, __eql, __a)</span>
<span id="L185"><span class="lineNum">     185</span>              :         { }</span>
<span id="L186"><span class="lineNum">     186</span>              : </span>
<span id="L187"><span class="lineNum">     187</span>              :       /// Copy constructor.</span>
<span id="L188"><span class="lineNum">     188</span>              :       unordered_map(const unordered_map&amp;) = default;</span>
<span id="L189"><span class="lineNum">     189</span>              : </span>
<span id="L190"><span class="lineNum">     190</span>              :       /// Move constructor.</span>
<span id="L191"><span class="lineNum">     191</span>              :       unordered_map(unordered_map&amp;&amp;) = default;</span>
<span id="L192"><span class="lineNum">     192</span>              : </span>
<span id="L193"><span class="lineNum">     193</span>              :       /**</span>
<span id="L194"><span class="lineNum">     194</span>              :        *  @brief Creates an %unordered_map with no elements.</span>
<span id="L195"><span class="lineNum">     195</span>              :        *  @param __a An allocator object.</span>
<span id="L196"><span class="lineNum">     196</span>              :        */</span>
<span id="L197"><span class="lineNum">     197</span>              :       explicit</span>
<span id="L198"><span class="lineNum">     198</span>              :       unordered_map(const allocator_type&amp; __a)</span>
<span id="L199"><span class="lineNum">     199</span>              :         : _M_h(__a)</span>
<span id="L200"><span class="lineNum">     200</span>              :       { }</span>
<span id="L201"><span class="lineNum">     201</span>              : </span>
<span id="L202"><span class="lineNum">     202</span>              :       /*</span>
<span id="L203"><span class="lineNum">     203</span>              :        *  @brief Copy constructor with allocator argument.</span>
<span id="L204"><span class="lineNum">     204</span>              :        * @param  __uset  Input %unordered_map to copy.</span>
<span id="L205"><span class="lineNum">     205</span>              :        * @param  __a  An allocator object.</span>
<span id="L206"><span class="lineNum">     206</span>              :        */</span>
<span id="L207"><span class="lineNum">     207</span>              :       unordered_map(const unordered_map&amp; __umap,</span>
<span id="L208"><span class="lineNum">     208</span>              :                     const allocator_type&amp; __a)</span>
<span id="L209"><span class="lineNum">     209</span>              :       : _M_h(__umap._M_h, __a)</span>
<span id="L210"><span class="lineNum">     210</span>              :       { }</span>
<span id="L211"><span class="lineNum">     211</span>              : </span>
<span id="L212"><span class="lineNum">     212</span>              :       /*</span>
<span id="L213"><span class="lineNum">     213</span>              :        *  @brief  Move constructor with allocator argument.</span>
<span id="L214"><span class="lineNum">     214</span>              :        *  @param  __uset Input %unordered_map to move.</span>
<span id="L215"><span class="lineNum">     215</span>              :        *  @param  __a    An allocator object.</span>
<span id="L216"><span class="lineNum">     216</span>              :        */</span>
<span id="L217"><span class="lineNum">     217</span>              :       unordered_map(unordered_map&amp;&amp; __umap,</span>
<span id="L218"><span class="lineNum">     218</span>              :                     const allocator_type&amp; __a)</span>
<span id="L219"><span class="lineNum">     219</span>              :         noexcept( noexcept(_Hashtable(std::move(__umap._M_h), __a)) )</span>
<span id="L220"><span class="lineNum">     220</span>              :       : _M_h(std::move(__umap._M_h), __a)</span>
<span id="L221"><span class="lineNum">     221</span>              :       { }</span>
<span id="L222"><span class="lineNum">     222</span>              : </span>
<span id="L223"><span class="lineNum">     223</span>              :       /**</span>
<span id="L224"><span class="lineNum">     224</span>              :        *  @brief  Builds an %unordered_map from an initializer_list.</span>
<span id="L225"><span class="lineNum">     225</span>              :        *  @param  __l  An initializer_list.</span>
<span id="L226"><span class="lineNum">     226</span>              :        *  @param __n  Minimal initial number of buckets.</span>
<span id="L227"><span class="lineNum">     227</span>              :        *  @param __hf  A hash functor.</span>
<span id="L228"><span class="lineNum">     228</span>              :        *  @param __eql  A key equality functor.</span>
<span id="L229"><span class="lineNum">     229</span>              :        *  @param  __a  An allocator object.</span>
<span id="L230"><span class="lineNum">     230</span>              :        *</span>
<span id="L231"><span class="lineNum">     231</span>              :        *  Create an %unordered_map consisting of copies of the elements in the</span>
<span id="L232"><span class="lineNum">     232</span>              :        *  list. This is linear in N (where N is @a __l.size()).</span>
<span id="L233"><span class="lineNum">     233</span>              :        */</span>
<span id="L234"><span class="lineNum">     234</span>              :       unordered_map(initializer_list&lt;value_type&gt; __l,</span>
<span id="L235"><span class="lineNum">     235</span>              :                     size_type __n = 0,</span>
<span id="L236"><span class="lineNum">     236</span>              :                     const hasher&amp; __hf = hasher(),</span>
<span id="L237"><span class="lineNum">     237</span>              :                     const key_equal&amp; __eql = key_equal(),</span>
<span id="L238"><span class="lineNum">     238</span>              :                     const allocator_type&amp; __a = allocator_type())</span>
<span id="L239"><span class="lineNum">     239</span>              :       : _M_h(__l, __n, __hf, __eql, __a)</span>
<span id="L240"><span class="lineNum">     240</span>              :       { }</span>
<span id="L241"><span class="lineNum">     241</span>              : </span>
<span id="L242"><span class="lineNum">     242</span>              :       unordered_map(size_type __n, const allocator_type&amp; __a)</span>
<span id="L243"><span class="lineNum">     243</span>              :       : unordered_map(__n, hasher(), key_equal(), __a)</span>
<span id="L244"><span class="lineNum">     244</span>              :       { }</span>
<span id="L245"><span class="lineNum">     245</span>              : </span>
<span id="L246"><span class="lineNum">     246</span>              :       unordered_map(size_type __n, const hasher&amp; __hf,</span>
<span id="L247"><span class="lineNum">     247</span>              :                     const allocator_type&amp; __a)</span>
<span id="L248"><span class="lineNum">     248</span>              :       : unordered_map(__n, __hf, key_equal(), __a)</span>
<span id="L249"><span class="lineNum">     249</span>              :       { }</span>
<span id="L250"><span class="lineNum">     250</span>              : </span>
<span id="L251"><span class="lineNum">     251</span>              :       template&lt;typename _InputIterator&gt;</span>
<span id="L252"><span class="lineNum">     252</span>              :         unordered_map(_InputIterator __first, _InputIterator __last,</span>
<span id="L253"><span class="lineNum">     253</span>              :                       size_type __n,</span>
<span id="L254"><span class="lineNum">     254</span>              :                       const allocator_type&amp; __a)</span>
<span id="L255"><span class="lineNum">     255</span>              :         : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)</span>
<span id="L256"><span class="lineNum">     256</span>              :         { }</span>
<span id="L257"><span class="lineNum">     257</span>              : </span>
<span id="L258"><span class="lineNum">     258</span>              :       template&lt;typename _InputIterator&gt;</span>
<span id="L259"><span class="lineNum">     259</span>              :         unordered_map(_InputIterator __first, _InputIterator __last,</span>
<span id="L260"><span class="lineNum">     260</span>              :                       size_type __n, const hasher&amp; __hf,</span>
<span id="L261"><span class="lineNum">     261</span>              :                       const allocator_type&amp; __a)</span>
<span id="L262"><span class="lineNum">     262</span>              :           : unordered_map(__first, __last, __n, __hf, key_equal(), __a)</span>
<span id="L263"><span class="lineNum">     263</span>              :         { }</span>
<span id="L264"><span class="lineNum">     264</span>              : </span>
<span id="L265"><span class="lineNum">     265</span>              :       unordered_map(initializer_list&lt;value_type&gt; __l,</span>
<span id="L266"><span class="lineNum">     266</span>              :                     size_type __n,</span>
<span id="L267"><span class="lineNum">     267</span>              :                     const allocator_type&amp; __a)</span>
<span id="L268"><span class="lineNum">     268</span>              :       : unordered_map(__l, __n, hasher(), key_equal(), __a)</span>
<span id="L269"><span class="lineNum">     269</span>              :       { }</span>
<span id="L270"><span class="lineNum">     270</span>              : </span>
<span id="L271"><span class="lineNum">     271</span>              :       unordered_map(initializer_list&lt;value_type&gt; __l,</span>
<span id="L272"><span class="lineNum">     272</span>              :                     size_type __n, const hasher&amp; __hf,</span>
<span id="L273"><span class="lineNum">     273</span>              :                     const allocator_type&amp; __a)</span>
<span id="L274"><span class="lineNum">     274</span>              :       : unordered_map(__l, __n, __hf, key_equal(), __a)</span>
<span id="L275"><span class="lineNum">     275</span>              :       { }</span>
<span id="L276"><span class="lineNum">     276</span>              : </span>
<span id="L277"><span class="lineNum">     277</span>              :       /// Copy assignment operator.</span>
<span id="L278"><span class="lineNum">     278</span>              :       unordered_map&amp;</span>
<span id="L279"><span class="lineNum">     279</span>              :       operator=(const unordered_map&amp;) = default;</span>
<span id="L280"><span class="lineNum">     280</span>              : </span>
<span id="L281"><span class="lineNum">     281</span>              :       /// Move assignment operator.</span>
<span id="L282"><span class="lineNum">     282</span>              :       unordered_map&amp;</span>
<span id="L283"><span class="lineNum">     283</span>              :       operator=(unordered_map&amp;&amp;) = default;</span>
<span id="L284"><span class="lineNum">     284</span>              : </span>
<span id="L285"><span class="lineNum">     285</span>              :       /**</span>
<span id="L286"><span class="lineNum">     286</span>              :        *  @brief  %Unordered_map list assignment operator.</span>
<span id="L287"><span class="lineNum">     287</span>              :        *  @param  __l  An initializer_list.</span>
<span id="L288"><span class="lineNum">     288</span>              :        *</span>
<span id="L289"><span class="lineNum">     289</span>              :        *  This function fills an %unordered_map with copies of the elements in</span>
<span id="L290"><span class="lineNum">     290</span>              :        *  the initializer list @a __l.</span>
<span id="L291"><span class="lineNum">     291</span>              :        *</span>
<span id="L292"><span class="lineNum">     292</span>              :        *  Note that the assignment completely changes the %unordered_map and</span>
<span id="L293"><span class="lineNum">     293</span>              :        *  that the resulting %unordered_map's size is the same as the number</span>
<span id="L294"><span class="lineNum">     294</span>              :        *  of elements assigned.</span>
<span id="L295"><span class="lineNum">     295</span>              :        */</span>
<span id="L296"><span class="lineNum">     296</span>              :       unordered_map&amp;</span>
<span id="L297"><span class="lineNum">     297</span>              :       operator=(initializer_list&lt;value_type&gt; __l)</span>
<span id="L298"><span class="lineNum">     298</span>              :       {</span>
<span id="L299"><span class="lineNum">     299</span>              :         _M_h = __l;</span>
<span id="L300"><span class="lineNum">     300</span>              :         return *this;</span>
<span id="L301"><span class="lineNum">     301</span>              :       }</span>
<span id="L302"><span class="lineNum">     302</span>              : </span>
<span id="L303"><span class="lineNum">     303</span>              :       ///  Returns the allocator object used by the %unordered_map.</span>
<span id="L304"><span class="lineNum">     304</span>              :       allocator_type</span>
<span id="L305"><span class="lineNum">     305</span>              :       get_allocator() const noexcept</span>
<span id="L306"><span class="lineNum">     306</span>              :       { return _M_h.get_allocator(); }</span>
<span id="L307"><span class="lineNum">     307</span>              : </span>
<span id="L308"><span class="lineNum">     308</span>              :       // size and capacity:</span>
<span id="L309"><span class="lineNum">     309</span>              : </span>
<span id="L310"><span class="lineNum">     310</span>              :       ///  Returns true if the %unordered_map is empty.</span>
<span id="L311"><span class="lineNum">     311</span>              :       _GLIBCXX_NODISCARD bool</span>
<span id="L312"><span class="lineNum">     312</span>              :       empty() const noexcept</span>
<span id="L313"><span class="lineNum">     313</span>              :       { return _M_h.empty(); }</span>
<span id="L314"><span class="lineNum">     314</span>              : </span>
<span id="L315"><span class="lineNum">     315</span>              :       ///  Returns the size of the %unordered_map.</span>
<span id="L316"><span class="lineNum">     316</span>              :       size_type</span>
<span id="L317"><span class="lineNum">     317</span>              :       size() const noexcept</span>
<span id="L318"><span class="lineNum">     318</span>              :       { return _M_h.size(); }</span>
<span id="L319"><span class="lineNum">     319</span>              : </span>
<span id="L320"><span class="lineNum">     320</span>              :       ///  Returns the maximum size of the %unordered_map.</span>
<span id="L321"><span class="lineNum">     321</span>              :       size_type</span>
<span id="L322"><span class="lineNum">     322</span>              :       max_size() const noexcept</span>
<span id="L323"><span class="lineNum">     323</span>              :       { return _M_h.max_size(); }</span>
<span id="L324"><span class="lineNum">     324</span>              : </span>
<span id="L325"><span class="lineNum">     325</span>              :       // iterators.</span>
<span id="L326"><span class="lineNum">     326</span>              : </span>
<span id="L327"><span class="lineNum">     327</span>              :       /**</span>
<span id="L328"><span class="lineNum">     328</span>              :        *  Returns a read/write iterator that points to the first element in the</span>
<span id="L329"><span class="lineNum">     329</span>              :        *  %unordered_map.</span>
<span id="L330"><span class="lineNum">     330</span>              :        */</span>
<span id="L331"><span class="lineNum">     331</span>              :       iterator</span>
<span id="L332"><span class="lineNum">     332</span>              :       begin() noexcept</span>
<span id="L333"><span class="lineNum">     333</span>              :       { return _M_h.begin(); }</span>
<span id="L334"><span class="lineNum">     334</span>              : </span>
<span id="L335"><span class="lineNum">     335</span>              :       ///@{</span>
<span id="L336"><span class="lineNum">     336</span>              :       /**</span>
<span id="L337"><span class="lineNum">     337</span>              :        *  Returns a read-only (constant) iterator that points to the first</span>
<span id="L338"><span class="lineNum">     338</span>              :        *  element in the %unordered_map.</span>
<span id="L339"><span class="lineNum">     339</span>              :        */</span>
<span id="L340"><span class="lineNum">     340</span>              :       const_iterator</span>
<span id="L341"><span class="lineNum">     341</span> <span class="tlaUNC tlaBgUNC">           0 :       begin() const noexcept</span></span>
<span id="L342"><span class="lineNum">     342</span> <span class="tlaUNC">           0 :       { return _M_h.begin(); }</span></span>
<span id="L343"><span class="lineNum">     343</span>              : </span>
<span id="L344"><span class="lineNum">     344</span>              :       const_iterator</span>
<span id="L345"><span class="lineNum">     345</span>              :       cbegin() const noexcept</span>
<span id="L346"><span class="lineNum">     346</span>              :       { return _M_h.begin(); }</span>
<span id="L347"><span class="lineNum">     347</span>              :       ///@}</span>
<span id="L348"><span class="lineNum">     348</span>              : </span>
<span id="L349"><span class="lineNum">     349</span>              :       /**</span>
<span id="L350"><span class="lineNum">     350</span>              :        *  Returns a read/write iterator that points one past the last element in</span>
<span id="L351"><span class="lineNum">     351</span>              :        *  the %unordered_map.</span>
<span id="L352"><span class="lineNum">     352</span>              :        */</span>
<span id="L353"><span class="lineNum">     353</span>              :       iterator</span>
<span id="L354"><span class="lineNum">     354</span> <span class="tlaGNC tlaBgGNC">           7 :       end() noexcept</span></span>
<span id="L355"><span class="lineNum">     355</span> <span class="tlaGNC">           7 :       { return _M_h.end(); }</span></span>
<span id="L356"><span class="lineNum">     356</span>              : </span>
<span id="L357"><span class="lineNum">     357</span>              :       ///@{</span>
<span id="L358"><span class="lineNum">     358</span>              :       /**</span>
<span id="L359"><span class="lineNum">     359</span>              :        *  Returns a read-only (constant) iterator that points one past the last</span>
<span id="L360"><span class="lineNum">     360</span>              :        *  element in the %unordered_map.</span>
<span id="L361"><span class="lineNum">     361</span>              :        */</span>
<span id="L362"><span class="lineNum">     362</span>              :       const_iterator</span>
<span id="L363"><span class="lineNum">     363</span> <span class="tlaUNC tlaBgUNC">           0 :       end() const noexcept</span></span>
<span id="L364"><span class="lineNum">     364</span> <span class="tlaUNC">           0 :       { return _M_h.end(); }</span></span>
<span id="L365"><span class="lineNum">     365</span>              : </span>
<span id="L366"><span class="lineNum">     366</span>              :       const_iterator</span>
<span id="L367"><span class="lineNum">     367</span>              :       cend() const noexcept</span>
<span id="L368"><span class="lineNum">     368</span>              :       { return _M_h.end(); }</span>
<span id="L369"><span class="lineNum">     369</span>              :       ///@}</span>
<span id="L370"><span class="lineNum">     370</span>              : </span>
<span id="L371"><span class="lineNum">     371</span>              :       // modifiers.</span>
<span id="L372"><span class="lineNum">     372</span>              : </span>
<span id="L373"><span class="lineNum">     373</span>              :       /**</span>
<span id="L374"><span class="lineNum">     374</span>              :        *  @brief Attempts to build and insert a std::pair into the</span>
<span id="L375"><span class="lineNum">     375</span>              :        *  %unordered_map.</span>
<span id="L376"><span class="lineNum">     376</span>              :        *</span>
<span id="L377"><span class="lineNum">     377</span>              :        *  @param __args  Arguments used to generate a new pair instance (see</span>
<span id="L378"><span class="lineNum">     378</span>              :        *                std::piecewise_contruct for passing arguments to each</span>
<span id="L379"><span class="lineNum">     379</span>              :        *                part of the pair constructor).</span>
<span id="L380"><span class="lineNum">     380</span>              :        *</span>
<span id="L381"><span class="lineNum">     381</span>              :        *  @return  A pair, of which the first element is an iterator that points</span>
<span id="L382"><span class="lineNum">     382</span>              :        *           to the possibly inserted pair, and the second is a bool that</span>
<span id="L383"><span class="lineNum">     383</span>              :        *           is true if the pair was actually inserted.</span>
<span id="L384"><span class="lineNum">     384</span>              :        *</span>
<span id="L385"><span class="lineNum">     385</span>              :        *  This function attempts to build and insert a (key, value) %pair into</span>
<span id="L386"><span class="lineNum">     386</span>              :        *  the %unordered_map.</span>
<span id="L387"><span class="lineNum">     387</span>              :        *  An %unordered_map relies on unique keys and thus a %pair is only</span>
<span id="L388"><span class="lineNum">     388</span>              :        *  inserted if its first element (the key) is not already present in the</span>
<span id="L389"><span class="lineNum">     389</span>              :        *  %unordered_map.</span>
<span id="L390"><span class="lineNum">     390</span>              :        *</span>
<span id="L391"><span class="lineNum">     391</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L392"><span class="lineNum">     392</span>              :        */</span>
<span id="L393"><span class="lineNum">     393</span>              :       template&lt;typename... _Args&gt;</span>
<span id="L394"><span class="lineNum">     394</span>              :         std::pair&lt;iterator, bool&gt;</span>
<span id="L395"><span class="lineNum">     395</span>              :         emplace(_Args&amp;&amp;... __args)</span>
<span id="L396"><span class="lineNum">     396</span>              :         { return _M_h.emplace(std::forward&lt;_Args&gt;(__args)...); }</span>
<span id="L397"><span class="lineNum">     397</span>              : </span>
<span id="L398"><span class="lineNum">     398</span>              :       /**</span>
<span id="L399"><span class="lineNum">     399</span>              :        *  @brief Attempts to build and insert a std::pair into the</span>
<span id="L400"><span class="lineNum">     400</span>              :        *  %unordered_map.</span>
<span id="L401"><span class="lineNum">     401</span>              :        *</span>
<span id="L402"><span class="lineNum">     402</span>              :        *  @param  __pos  An iterator that serves as a hint as to where the pair</span>
<span id="L403"><span class="lineNum">     403</span>              :        *                should be inserted.</span>
<span id="L404"><span class="lineNum">     404</span>              :        *  @param  __args  Arguments used to generate a new pair instance (see</span>
<span id="L405"><span class="lineNum">     405</span>              :        *                 std::piecewise_contruct for passing arguments to each</span>
<span id="L406"><span class="lineNum">     406</span>              :        *                 part of the pair constructor).</span>
<span id="L407"><span class="lineNum">     407</span>              :        *  @return An iterator that points to the element with key of the</span>
<span id="L408"><span class="lineNum">     408</span>              :        *          std::pair built from @a __args (may or may not be that</span>
<span id="L409"><span class="lineNum">     409</span>              :        *          std::pair).</span>
<span id="L410"><span class="lineNum">     410</span>              :        *</span>
<span id="L411"><span class="lineNum">     411</span>              :        *  This function is not concerned about whether the insertion took place,</span>
<span id="L412"><span class="lineNum">     412</span>              :        *  and thus does not return a boolean like the single-argument emplace()</span>
<span id="L413"><span class="lineNum">     413</span>              :        *  does.</span>
<span id="L414"><span class="lineNum">     414</span>              :        *  Note that the first parameter is only a hint and can potentially</span>
<span id="L415"><span class="lineNum">     415</span>              :        *  improve the performance of the insertion process. A bad hint would</span>
<span id="L416"><span class="lineNum">     416</span>              :        *  cause no gains in efficiency.</span>
<span id="L417"><span class="lineNum">     417</span>              :        *</span>
<span id="L418"><span class="lineNum">     418</span>              :        *  See</span>
<span id="L419"><span class="lineNum">     419</span>              :        *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints</span>
<span id="L420"><span class="lineNum">     420</span>              :        *  for more on @a hinting.</span>
<span id="L421"><span class="lineNum">     421</span>              :        *</span>
<span id="L422"><span class="lineNum">     422</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L423"><span class="lineNum">     423</span>              :        */</span>
<span id="L424"><span class="lineNum">     424</span>              :       template&lt;typename... _Args&gt;</span>
<span id="L425"><span class="lineNum">     425</span>              :         iterator</span>
<span id="L426"><span class="lineNum">     426</span>              :         emplace_hint(const_iterator __pos, _Args&amp;&amp;... __args)</span>
<span id="L427"><span class="lineNum">     427</span>              :         { return _M_h.emplace_hint(__pos, std::forward&lt;_Args&gt;(__args)...); }</span>
<span id="L428"><span class="lineNum">     428</span>              : </span>
<span id="L429"><span class="lineNum">     429</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L430"><span class="lineNum">     430</span>              :       /// Extract a node.</span>
<span id="L431"><span class="lineNum">     431</span>              :       node_type</span>
<span id="L432"><span class="lineNum">     432</span>              :       extract(const_iterator __pos)</span>
<span id="L433"><span class="lineNum">     433</span>              :       {</span>
<span id="L434"><span class="lineNum">     434</span>              :         __glibcxx_assert(__pos != end());</span>
<span id="L435"><span class="lineNum">     435</span>              :         return _M_h.extract(__pos);</span>
<span id="L436"><span class="lineNum">     436</span>              :       }</span>
<span id="L437"><span class="lineNum">     437</span>              : </span>
<span id="L438"><span class="lineNum">     438</span>              :       /// Extract a node.</span>
<span id="L439"><span class="lineNum">     439</span>              :       node_type</span>
<span id="L440"><span class="lineNum">     440</span>              :       extract(const key_type&amp; __key)</span>
<span id="L441"><span class="lineNum">     441</span>              :       { return _M_h.extract(__key); }</span>
<span id="L442"><span class="lineNum">     442</span>              : </span>
<span id="L443"><span class="lineNum">     443</span>              :       /// Re-insert an extracted node.</span>
<span id="L444"><span class="lineNum">     444</span>              :       insert_return_type</span>
<span id="L445"><span class="lineNum">     445</span>              :       insert(node_type&amp;&amp; __nh)</span>
<span id="L446"><span class="lineNum">     446</span>              :       { return _M_h._M_reinsert_node(std::move(__nh)); }</span>
<span id="L447"><span class="lineNum">     447</span>              : </span>
<span id="L448"><span class="lineNum">     448</span>              :       /// Re-insert an extracted node.</span>
<span id="L449"><span class="lineNum">     449</span>              :       iterator</span>
<span id="L450"><span class="lineNum">     450</span>              :       insert(const_iterator, node_type&amp;&amp; __nh)</span>
<span id="L451"><span class="lineNum">     451</span>              :       { return _M_h._M_reinsert_node(std::move(__nh)).position; }</span>
<span id="L452"><span class="lineNum">     452</span>              : </span>
<span id="L453"><span class="lineNum">     453</span>              : #define __cpp_lib_unordered_map_try_emplace 201411L</span>
<span id="L454"><span class="lineNum">     454</span>              :       /**</span>
<span id="L455"><span class="lineNum">     455</span>              :        *  @brief Attempts to build and insert a std::pair into the</span>
<span id="L456"><span class="lineNum">     456</span>              :        *  %unordered_map.</span>
<span id="L457"><span class="lineNum">     457</span>              :        *</span>
<span id="L458"><span class="lineNum">     458</span>              :        *  @param __k    Key to use for finding a possibly existing pair in</span>
<span id="L459"><span class="lineNum">     459</span>              :        *                the unordered_map.</span>
<span id="L460"><span class="lineNum">     460</span>              :        *  @param __args  Arguments used to generate the .second for a </span>
<span id="L461"><span class="lineNum">     461</span>              :        *                new pair instance.</span>
<span id="L462"><span class="lineNum">     462</span>              :        *</span>
<span id="L463"><span class="lineNum">     463</span>              :        *  @return  A pair, of which the first element is an iterator that points</span>
<span id="L464"><span class="lineNum">     464</span>              :        *           to the possibly inserted pair, and the second is a bool that</span>
<span id="L465"><span class="lineNum">     465</span>              :        *           is true if the pair was actually inserted.</span>
<span id="L466"><span class="lineNum">     466</span>              :        *</span>
<span id="L467"><span class="lineNum">     467</span>              :        *  This function attempts to build and insert a (key, value) %pair into</span>
<span id="L468"><span class="lineNum">     468</span>              :        *  the %unordered_map.</span>
<span id="L469"><span class="lineNum">     469</span>              :        *  An %unordered_map relies on unique keys and thus a %pair is only</span>
<span id="L470"><span class="lineNum">     470</span>              :        *  inserted if its first element (the key) is not already present in the</span>
<span id="L471"><span class="lineNum">     471</span>              :        *  %unordered_map.</span>
<span id="L472"><span class="lineNum">     472</span>              :        *  If a %pair is not inserted, this function has no effect.</span>
<span id="L473"><span class="lineNum">     473</span>              :        *</span>
<span id="L474"><span class="lineNum">     474</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L475"><span class="lineNum">     475</span>              :        */</span>
<span id="L476"><span class="lineNum">     476</span>              :       template &lt;typename... _Args&gt;</span>
<span id="L477"><span class="lineNum">     477</span>              :         pair&lt;iterator, bool&gt;</span>
<span id="L478"><span class="lineNum">     478</span>              :         try_emplace(const key_type&amp; __k, _Args&amp;&amp;... __args)</span>
<span id="L479"><span class="lineNum">     479</span>              :         {</span>
<span id="L480"><span class="lineNum">     480</span>              :           return _M_h.try_emplace(cend(), __k, std::forward&lt;_Args&gt;(__args)...);</span>
<span id="L481"><span class="lineNum">     481</span>              :         }</span>
<span id="L482"><span class="lineNum">     482</span>              : </span>
<span id="L483"><span class="lineNum">     483</span>              :       // move-capable overload</span>
<span id="L484"><span class="lineNum">     484</span>              :       template &lt;typename... _Args&gt;</span>
<span id="L485"><span class="lineNum">     485</span>              :         pair&lt;iterator, bool&gt;</span>
<span id="L486"><span class="lineNum">     486</span>              :         try_emplace(key_type&amp;&amp; __k, _Args&amp;&amp;... __args)</span>
<span id="L487"><span class="lineNum">     487</span>              :         {</span>
<span id="L488"><span class="lineNum">     488</span>              :           return _M_h.try_emplace(cend(), std::move(__k),</span>
<span id="L489"><span class="lineNum">     489</span>              :                                   std::forward&lt;_Args&gt;(__args)...);</span>
<span id="L490"><span class="lineNum">     490</span>              :         }</span>
<span id="L491"><span class="lineNum">     491</span>              : </span>
<span id="L492"><span class="lineNum">     492</span>              :       /**</span>
<span id="L493"><span class="lineNum">     493</span>              :        *  @brief Attempts to build and insert a std::pair into the</span>
<span id="L494"><span class="lineNum">     494</span>              :        *  %unordered_map.</span>
<span id="L495"><span class="lineNum">     495</span>              :        *</span>
<span id="L496"><span class="lineNum">     496</span>              :        *  @param  __hint  An iterator that serves as a hint as to where the pair</span>
<span id="L497"><span class="lineNum">     497</span>              :        *                should be inserted.</span>
<span id="L498"><span class="lineNum">     498</span>              :        *  @param __k    Key to use for finding a possibly existing pair in</span>
<span id="L499"><span class="lineNum">     499</span>              :        *                the unordered_map.</span>
<span id="L500"><span class="lineNum">     500</span>              :        *  @param __args  Arguments used to generate the .second for a </span>
<span id="L501"><span class="lineNum">     501</span>              :        *                new pair instance.</span>
<span id="L502"><span class="lineNum">     502</span>              :        *  @return An iterator that points to the element with key of the</span>
<span id="L503"><span class="lineNum">     503</span>              :        *          std::pair built from @a __args (may or may not be that</span>
<span id="L504"><span class="lineNum">     504</span>              :        *          std::pair).</span>
<span id="L505"><span class="lineNum">     505</span>              :        *</span>
<span id="L506"><span class="lineNum">     506</span>              :        *  This function is not concerned about whether the insertion took place,</span>
<span id="L507"><span class="lineNum">     507</span>              :        *  and thus does not return a boolean like the single-argument emplace()</span>
<span id="L508"><span class="lineNum">     508</span>              :        *  does. However, if insertion did not take place,</span>
<span id="L509"><span class="lineNum">     509</span>              :        *  this function has no effect.</span>
<span id="L510"><span class="lineNum">     510</span>              :        *  Note that the first parameter is only a hint and can potentially</span>
<span id="L511"><span class="lineNum">     511</span>              :        *  improve the performance of the insertion process. A bad hint would</span>
<span id="L512"><span class="lineNum">     512</span>              :        *  cause no gains in efficiency.</span>
<span id="L513"><span class="lineNum">     513</span>              :        *</span>
<span id="L514"><span class="lineNum">     514</span>              :        *  See</span>
<span id="L515"><span class="lineNum">     515</span>              :        *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints</span>
<span id="L516"><span class="lineNum">     516</span>              :        *  for more on @a hinting.</span>
<span id="L517"><span class="lineNum">     517</span>              :        *</span>
<span id="L518"><span class="lineNum">     518</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L519"><span class="lineNum">     519</span>              :        */</span>
<span id="L520"><span class="lineNum">     520</span>              :       template &lt;typename... _Args&gt;</span>
<span id="L521"><span class="lineNum">     521</span>              :         iterator</span>
<span id="L522"><span class="lineNum">     522</span>              :         try_emplace(const_iterator __hint, const key_type&amp; __k,</span>
<span id="L523"><span class="lineNum">     523</span>              :                     _Args&amp;&amp;... __args)</span>
<span id="L524"><span class="lineNum">     524</span>              :         {</span>
<span id="L525"><span class="lineNum">     525</span>              :           return _M_h.try_emplace(__hint, __k,</span>
<span id="L526"><span class="lineNum">     526</span>              :                                   std::forward&lt;_Args&gt;(__args)...).first;</span>
<span id="L527"><span class="lineNum">     527</span>              :         }</span>
<span id="L528"><span class="lineNum">     528</span>              : </span>
<span id="L529"><span class="lineNum">     529</span>              :       // move-capable overload</span>
<span id="L530"><span class="lineNum">     530</span>              :       template &lt;typename... _Args&gt;</span>
<span id="L531"><span class="lineNum">     531</span>              :         iterator</span>
<span id="L532"><span class="lineNum">     532</span>              :         try_emplace(const_iterator __hint, key_type&amp;&amp; __k, _Args&amp;&amp;... __args)</span>
<span id="L533"><span class="lineNum">     533</span>              :         {</span>
<span id="L534"><span class="lineNum">     534</span>              :           return _M_h.try_emplace(__hint, std::move(__k),</span>
<span id="L535"><span class="lineNum">     535</span>              :                                   std::forward&lt;_Args&gt;(__args)...).first;</span>
<span id="L536"><span class="lineNum">     536</span>              :         }</span>
<span id="L537"><span class="lineNum">     537</span>              : #endif // C++17</span>
<span id="L538"><span class="lineNum">     538</span>              : </span>
<span id="L539"><span class="lineNum">     539</span>              :       ///@{</span>
<span id="L540"><span class="lineNum">     540</span>              :       /**</span>
<span id="L541"><span class="lineNum">     541</span>              :        *  @brief Attempts to insert a std::pair into the %unordered_map.</span>
<span id="L542"><span class="lineNum">     542</span>              : </span>
<span id="L543"><span class="lineNum">     543</span>              :        *  @param __x Pair to be inserted (see std::make_pair for easy</span>
<span id="L544"><span class="lineNum">     544</span>              :        *             creation of pairs).</span>
<span id="L545"><span class="lineNum">     545</span>              :        *</span>
<span id="L546"><span class="lineNum">     546</span>              :        *  @return  A pair, of which the first element is an iterator that </span>
<span id="L547"><span class="lineNum">     547</span>              :        *           points to the possibly inserted pair, and the second is </span>
<span id="L548"><span class="lineNum">     548</span>              :        *           a bool that is true if the pair was actually inserted.</span>
<span id="L549"><span class="lineNum">     549</span>              :        *</span>
<span id="L550"><span class="lineNum">     550</span>              :        *  This function attempts to insert a (key, value) %pair into the</span>
<span id="L551"><span class="lineNum">     551</span>              :        *  %unordered_map. An %unordered_map relies on unique keys and thus a</span>
<span id="L552"><span class="lineNum">     552</span>              :        *  %pair is only inserted if its first element (the key) is not already</span>
<span id="L553"><span class="lineNum">     553</span>              :        *  present in the %unordered_map.</span>
<span id="L554"><span class="lineNum">     554</span>              :        *</span>
<span id="L555"><span class="lineNum">     555</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L556"><span class="lineNum">     556</span>              :        */</span>
<span id="L557"><span class="lineNum">     557</span>              :       std::pair&lt;iterator, bool&gt;</span>
<span id="L558"><span class="lineNum">     558</span>              :       insert(const value_type&amp; __x)</span>
<span id="L559"><span class="lineNum">     559</span>              :       { return _M_h.insert(__x); }</span>
<span id="L560"><span class="lineNum">     560</span>              : </span>
<span id="L561"><span class="lineNum">     561</span>              :       // _GLIBCXX_RESOLVE_LIB_DEFECTS</span>
<span id="L562"><span class="lineNum">     562</span>              :       // 2354. Unnecessary copying when inserting into maps with braced-init</span>
<span id="L563"><span class="lineNum">     563</span>              :       std::pair&lt;iterator, bool&gt;</span>
<span id="L564"><span class="lineNum">     564</span>              :       insert(value_type&amp;&amp; __x)</span>
<span id="L565"><span class="lineNum">     565</span>              :       { return _M_h.insert(std::move(__x)); }</span>
<span id="L566"><span class="lineNum">     566</span>              : </span>
<span id="L567"><span class="lineNum">     567</span>              :       template&lt;typename _Pair&gt;</span>
<span id="L568"><span class="lineNum">     568</span>              :         __enable_if_t&lt;is_constructible&lt;value_type, _Pair&amp;&amp;&gt;::value,</span>
<span id="L569"><span class="lineNum">     569</span>              :                       pair&lt;iterator, bool&gt;&gt;</span>
<span id="L570"><span class="lineNum">     570</span>              :         insert(_Pair&amp;&amp; __x)</span>
<span id="L571"><span class="lineNum">     571</span>              :         { return _M_h.emplace(std::forward&lt;_Pair&gt;(__x)); }</span>
<span id="L572"><span class="lineNum">     572</span>              :       ///@}</span>
<span id="L573"><span class="lineNum">     573</span>              : </span>
<span id="L574"><span class="lineNum">     574</span>              :       ///@{</span>
<span id="L575"><span class="lineNum">     575</span>              :       /**</span>
<span id="L576"><span class="lineNum">     576</span>              :        *  @brief Attempts to insert a std::pair into the %unordered_map.</span>
<span id="L577"><span class="lineNum">     577</span>              :        *  @param  __hint  An iterator that serves as a hint as to where the</span>
<span id="L578"><span class="lineNum">     578</span>              :        *                 pair should be inserted.</span>
<span id="L579"><span class="lineNum">     579</span>              :        *  @param  __x  Pair to be inserted (see std::make_pair for easy creation</span>
<span id="L580"><span class="lineNum">     580</span>              :        *               of pairs).</span>
<span id="L581"><span class="lineNum">     581</span>              :        *  @return An iterator that points to the element with key of</span>
<span id="L582"><span class="lineNum">     582</span>              :        *           @a __x (may or may not be the %pair passed in).</span>
<span id="L583"><span class="lineNum">     583</span>              :        *</span>
<span id="L584"><span class="lineNum">     584</span>              :        *  This function is not concerned about whether the insertion took place,</span>
<span id="L585"><span class="lineNum">     585</span>              :        *  and thus does not return a boolean like the single-argument insert()</span>
<span id="L586"><span class="lineNum">     586</span>              :        *  does.  Note that the first parameter is only a hint and can</span>
<span id="L587"><span class="lineNum">     587</span>              :        *  potentially improve the performance of the insertion process.  A bad</span>
<span id="L588"><span class="lineNum">     588</span>              :        *  hint would cause no gains in efficiency.</span>
<span id="L589"><span class="lineNum">     589</span>              :        *</span>
<span id="L590"><span class="lineNum">     590</span>              :        *  See</span>
<span id="L591"><span class="lineNum">     591</span>              :        *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints</span>
<span id="L592"><span class="lineNum">     592</span>              :        *  for more on @a hinting.</span>
<span id="L593"><span class="lineNum">     593</span>              :        *</span>
<span id="L594"><span class="lineNum">     594</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L595"><span class="lineNum">     595</span>              :        */</span>
<span id="L596"><span class="lineNum">     596</span>              :       iterator</span>
<span id="L597"><span class="lineNum">     597</span>              :       insert(const_iterator __hint, const value_type&amp; __x)</span>
<span id="L598"><span class="lineNum">     598</span>              :       { return _M_h.insert(__hint, __x); }</span>
<span id="L599"><span class="lineNum">     599</span>              : </span>
<span id="L600"><span class="lineNum">     600</span>              :       // _GLIBCXX_RESOLVE_LIB_DEFECTS</span>
<span id="L601"><span class="lineNum">     601</span>              :       // 2354. Unnecessary copying when inserting into maps with braced-init</span>
<span id="L602"><span class="lineNum">     602</span>              :       iterator</span>
<span id="L603"><span class="lineNum">     603</span>              :       insert(const_iterator __hint, value_type&amp;&amp; __x)</span>
<span id="L604"><span class="lineNum">     604</span>              :       { return _M_h.insert(__hint, std::move(__x)); }</span>
<span id="L605"><span class="lineNum">     605</span>              : </span>
<span id="L606"><span class="lineNum">     606</span>              :       template&lt;typename _Pair&gt;</span>
<span id="L607"><span class="lineNum">     607</span>              :         __enable_if_t&lt;is_constructible&lt;value_type, _Pair&amp;&amp;&gt;::value, iterator&gt;</span>
<span id="L608"><span class="lineNum">     608</span>              :         insert(const_iterator __hint, _Pair&amp;&amp; __x)</span>
<span id="L609"><span class="lineNum">     609</span>              :         { return _M_h.emplace_hint(__hint, std::forward&lt;_Pair&gt;(__x)); }</span>
<span id="L610"><span class="lineNum">     610</span>              :       ///@}</span>
<span id="L611"><span class="lineNum">     611</span>              : </span>
<span id="L612"><span class="lineNum">     612</span>              :       /**</span>
<span id="L613"><span class="lineNum">     613</span>              :        *  @brief A template function that attempts to insert a range of</span>
<span id="L614"><span class="lineNum">     614</span>              :        *  elements.</span>
<span id="L615"><span class="lineNum">     615</span>              :        *  @param  __first  Iterator pointing to the start of the range to be</span>
<span id="L616"><span class="lineNum">     616</span>              :        *                   inserted.</span>
<span id="L617"><span class="lineNum">     617</span>              :        *  @param  __last  Iterator pointing to the end of the range.</span>
<span id="L618"><span class="lineNum">     618</span>              :        *</span>
<span id="L619"><span class="lineNum">     619</span>              :        *  Complexity similar to that of the range constructor.</span>
<span id="L620"><span class="lineNum">     620</span>              :        */</span>
<span id="L621"><span class="lineNum">     621</span>              :       template&lt;typename _InputIterator&gt;</span>
<span id="L622"><span class="lineNum">     622</span>              :         void</span>
<span id="L623"><span class="lineNum">     623</span>              :         insert(_InputIterator __first, _InputIterator __last)</span>
<span id="L624"><span class="lineNum">     624</span>              :         { _M_h.insert(__first, __last); }</span>
<span id="L625"><span class="lineNum">     625</span>              : </span>
<span id="L626"><span class="lineNum">     626</span>              :       /**</span>
<span id="L627"><span class="lineNum">     627</span>              :        *  @brief Attempts to insert a list of elements into the %unordered_map.</span>
<span id="L628"><span class="lineNum">     628</span>              :        *  @param  __l  A std::initializer_list&lt;value_type&gt; of elements</span>
<span id="L629"><span class="lineNum">     629</span>              :        *               to be inserted.</span>
<span id="L630"><span class="lineNum">     630</span>              :        *</span>
<span id="L631"><span class="lineNum">     631</span>              :        *  Complexity similar to that of the range constructor.</span>
<span id="L632"><span class="lineNum">     632</span>              :        */</span>
<span id="L633"><span class="lineNum">     633</span>              :       void</span>
<span id="L634"><span class="lineNum">     634</span>              :       insert(initializer_list&lt;value_type&gt; __l)</span>
<span id="L635"><span class="lineNum">     635</span>              :       { _M_h.insert(__l); }</span>
<span id="L636"><span class="lineNum">     636</span>              : </span>
<span id="L637"><span class="lineNum">     637</span>              : </span>
<span id="L638"><span class="lineNum">     638</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L639"><span class="lineNum">     639</span>              :       /**</span>
<span id="L640"><span class="lineNum">     640</span>              :        *  @brief Attempts to insert a std::pair into the %unordered_map.</span>
<span id="L641"><span class="lineNum">     641</span>              :        *  @param __k    Key to use for finding a possibly existing pair in</span>
<span id="L642"><span class="lineNum">     642</span>              :        *                the map.</span>
<span id="L643"><span class="lineNum">     643</span>              :        *  @param __obj  Argument used to generate the .second for a pair </span>
<span id="L644"><span class="lineNum">     644</span>              :        *                instance.</span>
<span id="L645"><span class="lineNum">     645</span>              :        *</span>
<span id="L646"><span class="lineNum">     646</span>              :        *  @return  A pair, of which the first element is an iterator that </span>
<span id="L647"><span class="lineNum">     647</span>              :        *           points to the possibly inserted pair, and the second is </span>
<span id="L648"><span class="lineNum">     648</span>              :        *           a bool that is true if the pair was actually inserted.</span>
<span id="L649"><span class="lineNum">     649</span>              :        *</span>
<span id="L650"><span class="lineNum">     650</span>              :        *  This function attempts to insert a (key, value) %pair into the</span>
<span id="L651"><span class="lineNum">     651</span>              :        *  %unordered_map. An %unordered_map relies on unique keys and thus a</span>
<span id="L652"><span class="lineNum">     652</span>              :        *  %pair is only inserted if its first element (the key) is not already</span>
<span id="L653"><span class="lineNum">     653</span>              :        *  present in the %unordered_map.</span>
<span id="L654"><span class="lineNum">     654</span>              :        *  If the %pair was already in the %unordered_map, the .second of </span>
<span id="L655"><span class="lineNum">     655</span>              :        *  the %pair is assigned from __obj.</span>
<span id="L656"><span class="lineNum">     656</span>              :        *</span>
<span id="L657"><span class="lineNum">     657</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L658"><span class="lineNum">     658</span>              :        */</span>
<span id="L659"><span class="lineNum">     659</span>              :       template &lt;typename _Obj&gt;</span>
<span id="L660"><span class="lineNum">     660</span>              :         pair&lt;iterator, bool&gt;</span>
<span id="L661"><span class="lineNum">     661</span>              :         insert_or_assign(const key_type&amp; __k, _Obj&amp;&amp; __obj)</span>
<span id="L662"><span class="lineNum">     662</span>              :         {</span>
<span id="L663"><span class="lineNum">     663</span>              :           auto __ret = _M_h.try_emplace(cend(), __k,</span>
<span id="L664"><span class="lineNum">     664</span>              :                                         std::forward&lt;_Obj&gt;(__obj));</span>
<span id="L665"><span class="lineNum">     665</span>              :           if (!__ret.second)</span>
<span id="L666"><span class="lineNum">     666</span>              :             __ret.first-&gt;second = std::forward&lt;_Obj&gt;(__obj);</span>
<span id="L667"><span class="lineNum">     667</span>              :           return __ret;</span>
<span id="L668"><span class="lineNum">     668</span>              :         }</span>
<span id="L669"><span class="lineNum">     669</span>              : </span>
<span id="L670"><span class="lineNum">     670</span>              :       // move-capable overload</span>
<span id="L671"><span class="lineNum">     671</span>              :       template &lt;typename _Obj&gt;</span>
<span id="L672"><span class="lineNum">     672</span>              :         pair&lt;iterator, bool&gt;</span>
<span id="L673"><span class="lineNum">     673</span>              :         insert_or_assign(key_type&amp;&amp; __k, _Obj&amp;&amp; __obj)</span>
<span id="L674"><span class="lineNum">     674</span>              :         {</span>
<span id="L675"><span class="lineNum">     675</span>              :           auto __ret = _M_h.try_emplace(cend(), std::move(__k),</span>
<span id="L676"><span class="lineNum">     676</span>              :                                         std::forward&lt;_Obj&gt;(__obj));</span>
<span id="L677"><span class="lineNum">     677</span>              :           if (!__ret.second)</span>
<span id="L678"><span class="lineNum">     678</span>              :             __ret.first-&gt;second = std::forward&lt;_Obj&gt;(__obj);</span>
<span id="L679"><span class="lineNum">     679</span>              :           return __ret;</span>
<span id="L680"><span class="lineNum">     680</span>              :         }</span>
<span id="L681"><span class="lineNum">     681</span>              : </span>
<span id="L682"><span class="lineNum">     682</span>              :       /**</span>
<span id="L683"><span class="lineNum">     683</span>              :        *  @brief Attempts to insert a std::pair into the %unordered_map.</span>
<span id="L684"><span class="lineNum">     684</span>              :        *  @param  __hint  An iterator that serves as a hint as to where the</span>
<span id="L685"><span class="lineNum">     685</span>              :        *                  pair should be inserted.</span>
<span id="L686"><span class="lineNum">     686</span>              :        *  @param __k    Key to use for finding a possibly existing pair in</span>
<span id="L687"><span class="lineNum">     687</span>              :        *                the unordered_map.</span>
<span id="L688"><span class="lineNum">     688</span>              :        *  @param __obj  Argument used to generate the .second for a pair </span>
<span id="L689"><span class="lineNum">     689</span>              :        *                instance.</span>
<span id="L690"><span class="lineNum">     690</span>              :        *  @return An iterator that points to the element with key of</span>
<span id="L691"><span class="lineNum">     691</span>              :        *           @a __x (may or may not be the %pair passed in).</span>
<span id="L692"><span class="lineNum">     692</span>              :        *</span>
<span id="L693"><span class="lineNum">     693</span>              :        *  This function is not concerned about whether the insertion took place,</span>
<span id="L694"><span class="lineNum">     694</span>              :        *  and thus does not return a boolean like the single-argument insert()</span>
<span id="L695"><span class="lineNum">     695</span>              :        *  does.         </span>
<span id="L696"><span class="lineNum">     696</span>              :        *  If the %pair was already in the %unordered map, the .second of</span>
<span id="L697"><span class="lineNum">     697</span>              :        *  the %pair is assigned from __obj.</span>
<span id="L698"><span class="lineNum">     698</span>              :        *  Note that the first parameter is only a hint and can</span>
<span id="L699"><span class="lineNum">     699</span>              :        *  potentially improve the performance of the insertion process.  A bad</span>
<span id="L700"><span class="lineNum">     700</span>              :        *  hint would cause no gains in efficiency.</span>
<span id="L701"><span class="lineNum">     701</span>              :        *</span>
<span id="L702"><span class="lineNum">     702</span>              :        *  See</span>
<span id="L703"><span class="lineNum">     703</span>              :        *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints</span>
<span id="L704"><span class="lineNum">     704</span>              :        *  for more on @a hinting.</span>
<span id="L705"><span class="lineNum">     705</span>              :        *</span>
<span id="L706"><span class="lineNum">     706</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L707"><span class="lineNum">     707</span>              :        */</span>
<span id="L708"><span class="lineNum">     708</span>              :       template &lt;typename _Obj&gt;</span>
<span id="L709"><span class="lineNum">     709</span>              :         iterator</span>
<span id="L710"><span class="lineNum">     710</span>              :         insert_or_assign(const_iterator __hint, const key_type&amp; __k,</span>
<span id="L711"><span class="lineNum">     711</span>              :                          _Obj&amp;&amp; __obj)</span>
<span id="L712"><span class="lineNum">     712</span>              :         {</span>
<span id="L713"><span class="lineNum">     713</span>              :           auto __ret = _M_h.try_emplace(__hint, __k, std::forward&lt;_Obj&gt;(__obj));</span>
<span id="L714"><span class="lineNum">     714</span>              :           if (!__ret.second)</span>
<span id="L715"><span class="lineNum">     715</span>              :             __ret.first-&gt;second = std::forward&lt;_Obj&gt;(__obj);</span>
<span id="L716"><span class="lineNum">     716</span>              :           return __ret.first;</span>
<span id="L717"><span class="lineNum">     717</span>              :         }</span>
<span id="L718"><span class="lineNum">     718</span>              : </span>
<span id="L719"><span class="lineNum">     719</span>              :       // move-capable overload</span>
<span id="L720"><span class="lineNum">     720</span>              :       template &lt;typename _Obj&gt;</span>
<span id="L721"><span class="lineNum">     721</span>              :         iterator</span>
<span id="L722"><span class="lineNum">     722</span>              :         insert_or_assign(const_iterator __hint, key_type&amp;&amp; __k, _Obj&amp;&amp; __obj)</span>
<span id="L723"><span class="lineNum">     723</span>              :         {</span>
<span id="L724"><span class="lineNum">     724</span>              :           auto __ret = _M_h.try_emplace(__hint, std::move(__k),</span>
<span id="L725"><span class="lineNum">     725</span>              :                                         std::forward&lt;_Obj&gt;(__obj));</span>
<span id="L726"><span class="lineNum">     726</span>              :           if (!__ret.second)</span>
<span id="L727"><span class="lineNum">     727</span>              :             __ret.first-&gt;second = std::forward&lt;_Obj&gt;(__obj);</span>
<span id="L728"><span class="lineNum">     728</span>              :           return __ret.first;</span>
<span id="L729"><span class="lineNum">     729</span>              :         }</span>
<span id="L730"><span class="lineNum">     730</span>              : #endif</span>
<span id="L731"><span class="lineNum">     731</span>              : </span>
<span id="L732"><span class="lineNum">     732</span>              :       ///@{</span>
<span id="L733"><span class="lineNum">     733</span>              :       /**</span>
<span id="L734"><span class="lineNum">     734</span>              :        *  @brief Erases an element from an %unordered_map.</span>
<span id="L735"><span class="lineNum">     735</span>              :        *  @param  __position  An iterator pointing to the element to be erased.</span>
<span id="L736"><span class="lineNum">     736</span>              :        *  @return An iterator pointing to the element immediately following</span>
<span id="L737"><span class="lineNum">     737</span>              :        *          @a __position prior to the element being erased. If no such</span>
<span id="L738"><span class="lineNum">     738</span>              :        *          element exists, end() is returned.</span>
<span id="L739"><span class="lineNum">     739</span>              :        *</span>
<span id="L740"><span class="lineNum">     740</span>              :        *  This function erases an element, pointed to by the given iterator,</span>
<span id="L741"><span class="lineNum">     741</span>              :        *  from an %unordered_map.</span>
<span id="L742"><span class="lineNum">     742</span>              :        *  Note that this function only erases the element, and that if the</span>
<span id="L743"><span class="lineNum">     743</span>              :        *  element is itself a pointer, the pointed-to memory is not touched in</span>
<span id="L744"><span class="lineNum">     744</span>              :        *  any way.  Managing the pointer is the user's responsibility.</span>
<span id="L745"><span class="lineNum">     745</span>              :        */</span>
<span id="L746"><span class="lineNum">     746</span>              :       iterator</span>
<span id="L747"><span class="lineNum">     747</span>              :       erase(const_iterator __position)</span>
<span id="L748"><span class="lineNum">     748</span>              :       { return _M_h.erase(__position); }</span>
<span id="L749"><span class="lineNum">     749</span>              : </span>
<span id="L750"><span class="lineNum">     750</span>              :       // LWG 2059.</span>
<span id="L751"><span class="lineNum">     751</span>              :       iterator</span>
<span id="L752"><span class="lineNum">     752</span>              :       erase(iterator __position)</span>
<span id="L753"><span class="lineNum">     753</span>              :       { return _M_h.erase(__position); }</span>
<span id="L754"><span class="lineNum">     754</span>              :       ///@}</span>
<span id="L755"><span class="lineNum">     755</span>              : </span>
<span id="L756"><span class="lineNum">     756</span>              :       /**</span>
<span id="L757"><span class="lineNum">     757</span>              :        *  @brief Erases elements according to the provided key.</span>
<span id="L758"><span class="lineNum">     758</span>              :        *  @param  __x  Key of element to be erased.</span>
<span id="L759"><span class="lineNum">     759</span>              :        *  @return  The number of elements erased.</span>
<span id="L760"><span class="lineNum">     760</span>              :        *</span>
<span id="L761"><span class="lineNum">     761</span>              :        *  This function erases all the elements located by the given key from</span>
<span id="L762"><span class="lineNum">     762</span>              :        *  an %unordered_map. For an %unordered_map the result of this function</span>
<span id="L763"><span class="lineNum">     763</span>              :        *  can only be 0 (not present) or 1 (present).</span>
<span id="L764"><span class="lineNum">     764</span>              :        *  Note that this function only erases the element, and that if the</span>
<span id="L765"><span class="lineNum">     765</span>              :        *  element is itself a pointer, the pointed-to memory is not touched in</span>
<span id="L766"><span class="lineNum">     766</span>              :        *  any way.  Managing the pointer is the user's responsibility.</span>
<span id="L767"><span class="lineNum">     767</span>              :        */</span>
<span id="L768"><span class="lineNum">     768</span>              :       size_type</span>
<span id="L769"><span class="lineNum">     769</span> <span class="tlaUNC">           0 :       erase(const key_type&amp; __x)</span></span>
<span id="L770"><span class="lineNum">     770</span> <span class="tlaUNC">           0 :       { return _M_h.erase(__x); }</span></span>
<span id="L771"><span class="lineNum">     771</span>              : </span>
<span id="L772"><span class="lineNum">     772</span>              :       /**</span>
<span id="L773"><span class="lineNum">     773</span>              :        *  @brief Erases a [__first,__last) range of elements from an</span>
<span id="L774"><span class="lineNum">     774</span>              :        *  %unordered_map.</span>
<span id="L775"><span class="lineNum">     775</span>              :        *  @param  __first  Iterator pointing to the start of the range to be</span>
<span id="L776"><span class="lineNum">     776</span>              :        *                  erased.</span>
<span id="L777"><span class="lineNum">     777</span>              :        *  @param __last  Iterator pointing to the end of the range to</span>
<span id="L778"><span class="lineNum">     778</span>              :        *                be erased.</span>
<span id="L779"><span class="lineNum">     779</span>              :        *  @return The iterator @a __last.</span>
<span id="L780"><span class="lineNum">     780</span>              :        *</span>
<span id="L781"><span class="lineNum">     781</span>              :        *  This function erases a sequence of elements from an %unordered_map.</span>
<span id="L782"><span class="lineNum">     782</span>              :        *  Note that this function only erases the elements, and that if</span>
<span id="L783"><span class="lineNum">     783</span>              :        *  the element is itself a pointer, the pointed-to memory is not touched</span>
<span id="L784"><span class="lineNum">     784</span>              :        *  in any way.  Managing the pointer is the user's responsibility.</span>
<span id="L785"><span class="lineNum">     785</span>              :        */</span>
<span id="L786"><span class="lineNum">     786</span>              :       iterator</span>
<span id="L787"><span class="lineNum">     787</span>              :       erase(const_iterator __first, const_iterator __last)</span>
<span id="L788"><span class="lineNum">     788</span>              :       { return _M_h.erase(__first, __last); }</span>
<span id="L789"><span class="lineNum">     789</span>              : </span>
<span id="L790"><span class="lineNum">     790</span>              :       /**</span>
<span id="L791"><span class="lineNum">     791</span>              :        *  Erases all elements in an %unordered_map.</span>
<span id="L792"><span class="lineNum">     792</span>              :        *  Note that this function only erases the elements, and that if the</span>
<span id="L793"><span class="lineNum">     793</span>              :        *  elements themselves are pointers, the pointed-to memory is not touched</span>
<span id="L794"><span class="lineNum">     794</span>              :        *  in any way.  Managing the pointer is the user's responsibility.</span>
<span id="L795"><span class="lineNum">     795</span>              :        */</span>
<span id="L796"><span class="lineNum">     796</span>              :       void</span>
<span id="L797"><span class="lineNum">     797</span>              :       clear() noexcept</span>
<span id="L798"><span class="lineNum">     798</span>              :       { _M_h.clear(); }</span>
<span id="L799"><span class="lineNum">     799</span>              : </span>
<span id="L800"><span class="lineNum">     800</span>              :       /**</span>
<span id="L801"><span class="lineNum">     801</span>              :        *  @brief  Swaps data with another %unordered_map.</span>
<span id="L802"><span class="lineNum">     802</span>              :        *  @param  __x  An %unordered_map of the same element and allocator</span>
<span id="L803"><span class="lineNum">     803</span>              :        *  types.</span>
<span id="L804"><span class="lineNum">     804</span>              :        *</span>
<span id="L805"><span class="lineNum">     805</span>              :        *  This exchanges the elements between two %unordered_map in constant</span>
<span id="L806"><span class="lineNum">     806</span>              :        *  time.</span>
<span id="L807"><span class="lineNum">     807</span>              :        *  Note that the global std::swap() function is specialized such that</span>
<span id="L808"><span class="lineNum">     808</span>              :        *  std::swap(m1,m2) will feed to this function.</span>
<span id="L809"><span class="lineNum">     809</span>              :        */</span>
<span id="L810"><span class="lineNum">     810</span>              :       void</span>
<span id="L811"><span class="lineNum">     811</span>              :       swap(unordered_map&amp; __x)</span>
<span id="L812"><span class="lineNum">     812</span>              :       noexcept( noexcept(_M_h.swap(__x._M_h)) )</span>
<span id="L813"><span class="lineNum">     813</span>              :       { _M_h.swap(__x._M_h); }</span>
<span id="L814"><span class="lineNum">     814</span>              : </span>
<span id="L815"><span class="lineNum">     815</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L816"><span class="lineNum">     816</span>              :       template&lt;typename, typename, typename&gt;</span>
<span id="L817"><span class="lineNum">     817</span>              :         friend class std::_Hash_merge_helper;</span>
<span id="L818"><span class="lineNum">     818</span>              : </span>
<span id="L819"><span class="lineNum">     819</span>              :       template&lt;typename _H2, typename _P2&gt;</span>
<span id="L820"><span class="lineNum">     820</span>              :         void</span>
<span id="L821"><span class="lineNum">     821</span>              :         merge(unordered_map&lt;_Key, _Tp, _H2, _P2, _Alloc&gt;&amp; __source)</span>
<span id="L822"><span class="lineNum">     822</span>              :         {</span>
<span id="L823"><span class="lineNum">     823</span>              :           using _Merge_helper = _Hash_merge_helper&lt;unordered_map, _H2, _P2&gt;;</span>
<span id="L824"><span class="lineNum">     824</span>              :           _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));</span>
<span id="L825"><span class="lineNum">     825</span>              :         }</span>
<span id="L826"><span class="lineNum">     826</span>              : </span>
<span id="L827"><span class="lineNum">     827</span>              :       template&lt;typename _H2, typename _P2&gt;</span>
<span id="L828"><span class="lineNum">     828</span>              :         void</span>
<span id="L829"><span class="lineNum">     829</span>              :         merge(unordered_map&lt;_Key, _Tp, _H2, _P2, _Alloc&gt;&amp;&amp; __source)</span>
<span id="L830"><span class="lineNum">     830</span>              :         { merge(__source); }</span>
<span id="L831"><span class="lineNum">     831</span>              : </span>
<span id="L832"><span class="lineNum">     832</span>              :       template&lt;typename _H2, typename _P2&gt;</span>
<span id="L833"><span class="lineNum">     833</span>              :         void</span>
<span id="L834"><span class="lineNum">     834</span>              :         merge(unordered_multimap&lt;_Key, _Tp, _H2, _P2, _Alloc&gt;&amp; __source)</span>
<span id="L835"><span class="lineNum">     835</span>              :         {</span>
<span id="L836"><span class="lineNum">     836</span>              :           using _Merge_helper = _Hash_merge_helper&lt;unordered_map, _H2, _P2&gt;;</span>
<span id="L837"><span class="lineNum">     837</span>              :           _M_h._M_merge_unique(_Merge_helper::_S_get_table(__source));</span>
<span id="L838"><span class="lineNum">     838</span>              :         }</span>
<span id="L839"><span class="lineNum">     839</span>              : </span>
<span id="L840"><span class="lineNum">     840</span>              :       template&lt;typename _H2, typename _P2&gt;</span>
<span id="L841"><span class="lineNum">     841</span>              :         void</span>
<span id="L842"><span class="lineNum">     842</span>              :         merge(unordered_multimap&lt;_Key, _Tp, _H2, _P2, _Alloc&gt;&amp;&amp; __source)</span>
<span id="L843"><span class="lineNum">     843</span>              :         { merge(__source); }</span>
<span id="L844"><span class="lineNum">     844</span>              : #endif // C++17</span>
<span id="L845"><span class="lineNum">     845</span>              : </span>
<span id="L846"><span class="lineNum">     846</span>              :       // observers.</span>
<span id="L847"><span class="lineNum">     847</span>              : </span>
<span id="L848"><span class="lineNum">     848</span>              :       ///  Returns the hash functor object with which the %unordered_map was</span>
<span id="L849"><span class="lineNum">     849</span>              :       ///  constructed.</span>
<span id="L850"><span class="lineNum">     850</span>              :       hasher</span>
<span id="L851"><span class="lineNum">     851</span>              :       hash_function() const</span>
<span id="L852"><span class="lineNum">     852</span>              :       { return _M_h.hash_function(); }</span>
<span id="L853"><span class="lineNum">     853</span>              : </span>
<span id="L854"><span class="lineNum">     854</span>              :       ///  Returns the key comparison object with which the %unordered_map was</span>
<span id="L855"><span class="lineNum">     855</span>              :       ///  constructed.</span>
<span id="L856"><span class="lineNum">     856</span>              :       key_equal</span>
<span id="L857"><span class="lineNum">     857</span>              :       key_eq() const</span>
<span id="L858"><span class="lineNum">     858</span>              :       { return _M_h.key_eq(); }</span>
<span id="L859"><span class="lineNum">     859</span>              : </span>
<span id="L860"><span class="lineNum">     860</span>              :       // lookup.</span>
<span id="L861"><span class="lineNum">     861</span>              : </span>
<span id="L862"><span class="lineNum">     862</span>              :       ///@{</span>
<span id="L863"><span class="lineNum">     863</span>              :       /**</span>
<span id="L864"><span class="lineNum">     864</span>              :        *  @brief Tries to locate an element in an %unordered_map.</span>
<span id="L865"><span class="lineNum">     865</span>              :        *  @param  __x  Key to be located.</span>
<span id="L866"><span class="lineNum">     866</span>              :        *  @return  Iterator pointing to sought-after element, or end() if not</span>
<span id="L867"><span class="lineNum">     867</span>              :        *           found.</span>
<span id="L868"><span class="lineNum">     868</span>              :        *</span>
<span id="L869"><span class="lineNum">     869</span>              :        *  This function takes a key and tries to locate the element with which</span>
<span id="L870"><span class="lineNum">     870</span>              :        *  the key matches.  If successful the function returns an iterator</span>
<span id="L871"><span class="lineNum">     871</span>              :        *  pointing to the sought after element.  If unsuccessful it returns the</span>
<span id="L872"><span class="lineNum">     872</span>              :        *  past-the-end ( @c end() ) iterator.</span>
<span id="L873"><span class="lineNum">     873</span>              :        */</span>
<span id="L874"><span class="lineNum">     874</span>              :       iterator</span>
<span id="L875"><span class="lineNum">     875</span> <span class="tlaGNC tlaBgGNC">           7 :       find(const key_type&amp; __x)</span></span>
<span id="L876"><span class="lineNum">     876</span> <span class="tlaGNC">           7 :       { return _M_h.find(__x); }</span></span>
<span id="L877"><span class="lineNum">     877</span>              : </span>
<span id="L878"><span class="lineNum">     878</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L879"><span class="lineNum">     879</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L880"><span class="lineNum">     880</span>              :         auto</span>
<span id="L881"><span class="lineNum">     881</span>              :         find(const _Kt&amp; __x) -&gt; decltype(_M_h._M_find_tr(__x))</span>
<span id="L882"><span class="lineNum">     882</span>              :         { return _M_h._M_find_tr(__x); }</span>
<span id="L883"><span class="lineNum">     883</span>              : #endif</span>
<span id="L884"><span class="lineNum">     884</span>              : </span>
<span id="L885"><span class="lineNum">     885</span>              :       const_iterator</span>
<span id="L886"><span class="lineNum">     886</span>              :       find(const key_type&amp; __x) const</span>
<span id="L887"><span class="lineNum">     887</span>              :       { return _M_h.find(__x); }</span>
<span id="L888"><span class="lineNum">     888</span>              : </span>
<span id="L889"><span class="lineNum">     889</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L890"><span class="lineNum">     890</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L891"><span class="lineNum">     891</span>              :         auto</span>
<span id="L892"><span class="lineNum">     892</span>              :         find(const _Kt&amp; __x) const -&gt; decltype(_M_h._M_find_tr(__x))</span>
<span id="L893"><span class="lineNum">     893</span>              :         { return _M_h._M_find_tr(__x); }</span>
<span id="L894"><span class="lineNum">     894</span>              : #endif</span>
<span id="L895"><span class="lineNum">     895</span>              :       ///@}</span>
<span id="L896"><span class="lineNum">     896</span>              : </span>
<span id="L897"><span class="lineNum">     897</span>              :       ///@{</span>
<span id="L898"><span class="lineNum">     898</span>              :       /**</span>
<span id="L899"><span class="lineNum">     899</span>              :        *  @brief  Finds the number of elements.</span>
<span id="L900"><span class="lineNum">     900</span>              :        *  @param  __x  Key to count.</span>
<span id="L901"><span class="lineNum">     901</span>              :        *  @return  Number of elements with specified key.</span>
<span id="L902"><span class="lineNum">     902</span>              :        *</span>
<span id="L903"><span class="lineNum">     903</span>              :        *  This function only makes sense for %unordered_multimap; for</span>
<span id="L904"><span class="lineNum">     904</span>              :        *  %unordered_map the result will either be 0 (not present) or 1</span>
<span id="L905"><span class="lineNum">     905</span>              :        *  (present).</span>
<span id="L906"><span class="lineNum">     906</span>              :        */</span>
<span id="L907"><span class="lineNum">     907</span>              :       size_type</span>
<span id="L908"><span class="lineNum">     908</span>              :       count(const key_type&amp; __x) const</span>
<span id="L909"><span class="lineNum">     909</span>              :       { return _M_h.count(__x); }</span>
<span id="L910"><span class="lineNum">     910</span>              : </span>
<span id="L911"><span class="lineNum">     911</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L912"><span class="lineNum">     912</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L913"><span class="lineNum">     913</span>              :         auto</span>
<span id="L914"><span class="lineNum">     914</span>              :         count(const _Kt&amp; __x) const -&gt; decltype(_M_h._M_count_tr(__x))</span>
<span id="L915"><span class="lineNum">     915</span>              :         { return _M_h._M_count_tr(__x); }</span>
<span id="L916"><span class="lineNum">     916</span>              : #endif</span>
<span id="L917"><span class="lineNum">     917</span>              :       ///@}</span>
<span id="L918"><span class="lineNum">     918</span>              : </span>
<span id="L919"><span class="lineNum">     919</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L920"><span class="lineNum">     920</span>              :       ///@{</span>
<span id="L921"><span class="lineNum">     921</span>              :       /**</span>
<span id="L922"><span class="lineNum">     922</span>              :        *  @brief  Finds whether an element with the given key exists.</span>
<span id="L923"><span class="lineNum">     923</span>              :        *  @param  __x  Key of elements to be located.</span>
<span id="L924"><span class="lineNum">     924</span>              :        *  @return  True if there is any element with the specified key.</span>
<span id="L925"><span class="lineNum">     925</span>              :        */</span>
<span id="L926"><span class="lineNum">     926</span>              :       bool</span>
<span id="L927"><span class="lineNum">     927</span>              :       contains(const key_type&amp; __x) const</span>
<span id="L928"><span class="lineNum">     928</span>              :       { return _M_h.find(__x) != _M_h.end(); }</span>
<span id="L929"><span class="lineNum">     929</span>              : </span>
<span id="L930"><span class="lineNum">     930</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L931"><span class="lineNum">     931</span>              :         auto</span>
<span id="L932"><span class="lineNum">     932</span>              :         contains(const _Kt&amp; __x) const</span>
<span id="L933"><span class="lineNum">     933</span>              :         -&gt; decltype(_M_h._M_find_tr(__x), void(), true)</span>
<span id="L934"><span class="lineNum">     934</span>              :         { return _M_h._M_find_tr(__x) != _M_h.end(); }</span>
<span id="L935"><span class="lineNum">     935</span>              :       ///@}</span>
<span id="L936"><span class="lineNum">     936</span>              : #endif</span>
<span id="L937"><span class="lineNum">     937</span>              : </span>
<span id="L938"><span class="lineNum">     938</span>              :       ///@{</span>
<span id="L939"><span class="lineNum">     939</span>              :       /**</span>
<span id="L940"><span class="lineNum">     940</span>              :        *  @brief Finds a subsequence matching given key.</span>
<span id="L941"><span class="lineNum">     941</span>              :        *  @param  __x  Key to be located.</span>
<span id="L942"><span class="lineNum">     942</span>              :        *  @return  Pair of iterators that possibly points to the subsequence</span>
<span id="L943"><span class="lineNum">     943</span>              :        *           matching given key.</span>
<span id="L944"><span class="lineNum">     944</span>              :        *</span>
<span id="L945"><span class="lineNum">     945</span>              :        *  This function probably only makes sense for %unordered_multimap.</span>
<span id="L946"><span class="lineNum">     946</span>              :        */</span>
<span id="L947"><span class="lineNum">     947</span>              :       std::pair&lt;iterator, iterator&gt;</span>
<span id="L948"><span class="lineNum">     948</span>              :       equal_range(const key_type&amp; __x)</span>
<span id="L949"><span class="lineNum">     949</span>              :       { return _M_h.equal_range(__x); }</span>
<span id="L950"><span class="lineNum">     950</span>              : </span>
<span id="L951"><span class="lineNum">     951</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L952"><span class="lineNum">     952</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L953"><span class="lineNum">     953</span>              :         auto</span>
<span id="L954"><span class="lineNum">     954</span>              :         equal_range(const _Kt&amp; __x)</span>
<span id="L955"><span class="lineNum">     955</span>              :         -&gt; decltype(_M_h._M_equal_range_tr(__x))</span>
<span id="L956"><span class="lineNum">     956</span>              :         { return _M_h._M_equal_range_tr(__x); }</span>
<span id="L957"><span class="lineNum">     957</span>              : #endif</span>
<span id="L958"><span class="lineNum">     958</span>              : </span>
<span id="L959"><span class="lineNum">     959</span>              :       std::pair&lt;const_iterator, const_iterator&gt;</span>
<span id="L960"><span class="lineNum">     960</span>              :       equal_range(const key_type&amp; __x) const</span>
<span id="L961"><span class="lineNum">     961</span>              :       { return _M_h.equal_range(__x); }</span>
<span id="L962"><span class="lineNum">     962</span>              : </span>
<span id="L963"><span class="lineNum">     963</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L964"><span class="lineNum">     964</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L965"><span class="lineNum">     965</span>              :         auto</span>
<span id="L966"><span class="lineNum">     966</span>              :         equal_range(const _Kt&amp; __x) const</span>
<span id="L967"><span class="lineNum">     967</span>              :         -&gt; decltype(_M_h._M_equal_range_tr(__x))</span>
<span id="L968"><span class="lineNum">     968</span>              :         { return _M_h._M_equal_range_tr(__x); }</span>
<span id="L969"><span class="lineNum">     969</span>              : #endif</span>
<span id="L970"><span class="lineNum">     970</span>              :       ///@}</span>
<span id="L971"><span class="lineNum">     971</span>              : </span>
<span id="L972"><span class="lineNum">     972</span>              :       ///@{</span>
<span id="L973"><span class="lineNum">     973</span>              :       /**</span>
<span id="L974"><span class="lineNum">     974</span>              :        *  @brief  Subscript ( @c [] ) access to %unordered_map data.</span>
<span id="L975"><span class="lineNum">     975</span>              :        *  @param  __k  The key for which data should be retrieved.</span>
<span id="L976"><span class="lineNum">     976</span>              :        *  @return  A reference to the data of the (key,data) %pair.</span>
<span id="L977"><span class="lineNum">     977</span>              :        *</span>
<span id="L978"><span class="lineNum">     978</span>              :        *  Allows for easy lookup with the subscript ( @c [] )operator.  Returns</span>
<span id="L979"><span class="lineNum">     979</span>              :        *  data associated with the key specified in subscript.  If the key does</span>
<span id="L980"><span class="lineNum">     980</span>              :        *  not exist, a pair with that key is created using default values, which</span>
<span id="L981"><span class="lineNum">     981</span>              :        *  is then returned.</span>
<span id="L982"><span class="lineNum">     982</span>              :        *</span>
<span id="L983"><span class="lineNum">     983</span>              :        *  Lookup requires constant time.</span>
<span id="L984"><span class="lineNum">     984</span>              :        */</span>
<span id="L985"><span class="lineNum">     985</span>              :       mapped_type&amp;</span>
<span id="L986"><span class="lineNum">     986</span> <span class="tlaGNC">           2 :       operator[](const key_type&amp; __k)</span></span>
<span id="L987"><span class="lineNum">     987</span> <span class="tlaGNC">           2 :       { return _M_h[__k]; }</span></span>
<span id="L988"><span class="lineNum">     988</span>              : </span>
<span id="L989"><span class="lineNum">     989</span>              :       mapped_type&amp;</span>
<span id="L990"><span class="lineNum">     990</span>              :       operator[](key_type&amp;&amp; __k)</span>
<span id="L991"><span class="lineNum">     991</span>              :       { return _M_h[std::move(__k)]; }</span>
<span id="L992"><span class="lineNum">     992</span>              :       ///@}</span>
<span id="L993"><span class="lineNum">     993</span>              : </span>
<span id="L994"><span class="lineNum">     994</span>              :       ///@{</span>
<span id="L995"><span class="lineNum">     995</span>              :       /**</span>
<span id="L996"><span class="lineNum">     996</span>              :        *  @brief  Access to %unordered_map data.</span>
<span id="L997"><span class="lineNum">     997</span>              :        *  @param  __k  The key for which data should be retrieved.</span>
<span id="L998"><span class="lineNum">     998</span>              :        *  @return  A reference to the data whose key is equal to @a __k, if</span>
<span id="L999"><span class="lineNum">     999</span>              :        *           such a data is present in the %unordered_map.</span>
<span id="L1000"><span class="lineNum">    1000</span>              :        *  @throw  std::out_of_range  If no such data is present.</span>
<span id="L1001"><span class="lineNum">    1001</span>              :        */</span>
<span id="L1002"><span class="lineNum">    1002</span>              :       mapped_type&amp;</span>
<span id="L1003"><span class="lineNum">    1003</span>              :       at(const key_type&amp; __k)</span>
<span id="L1004"><span class="lineNum">    1004</span>              :       { return _M_h.at(__k); }</span>
<span id="L1005"><span class="lineNum">    1005</span>              : </span>
<span id="L1006"><span class="lineNum">    1006</span>              :       const mapped_type&amp;</span>
<span id="L1007"><span class="lineNum">    1007</span>              :       at(const key_type&amp; __k) const</span>
<span id="L1008"><span class="lineNum">    1008</span>              :       { return _M_h.at(__k); }</span>
<span id="L1009"><span class="lineNum">    1009</span>              :       ///@}</span>
<span id="L1010"><span class="lineNum">    1010</span>              : </span>
<span id="L1011"><span class="lineNum">    1011</span>              :       // bucket interface.</span>
<span id="L1012"><span class="lineNum">    1012</span>              : </span>
<span id="L1013"><span class="lineNum">    1013</span>              :       /// Returns the number of buckets of the %unordered_map.</span>
<span id="L1014"><span class="lineNum">    1014</span>              :       size_type</span>
<span id="L1015"><span class="lineNum">    1015</span>              :       bucket_count() const noexcept</span>
<span id="L1016"><span class="lineNum">    1016</span>              :       { return _M_h.bucket_count(); }</span>
<span id="L1017"><span class="lineNum">    1017</span>              : </span>
<span id="L1018"><span class="lineNum">    1018</span>              :       /// Returns the maximum number of buckets of the %unordered_map.</span>
<span id="L1019"><span class="lineNum">    1019</span>              :       size_type</span>
<span id="L1020"><span class="lineNum">    1020</span>              :       max_bucket_count() const noexcept</span>
<span id="L1021"><span class="lineNum">    1021</span>              :       { return _M_h.max_bucket_count(); }</span>
<span id="L1022"><span class="lineNum">    1022</span>              : </span>
<span id="L1023"><span class="lineNum">    1023</span>              :       /*</span>
<span id="L1024"><span class="lineNum">    1024</span>              :        * @brief  Returns the number of elements in a given bucket.</span>
<span id="L1025"><span class="lineNum">    1025</span>              :        * @param  __n  A bucket index.</span>
<span id="L1026"><span class="lineNum">    1026</span>              :        * @return  The number of elements in the bucket.</span>
<span id="L1027"><span class="lineNum">    1027</span>              :        */</span>
<span id="L1028"><span class="lineNum">    1028</span>              :       size_type</span>
<span id="L1029"><span class="lineNum">    1029</span>              :       bucket_size(size_type __n) const</span>
<span id="L1030"><span class="lineNum">    1030</span>              :       { return _M_h.bucket_size(__n); }</span>
<span id="L1031"><span class="lineNum">    1031</span>              : </span>
<span id="L1032"><span class="lineNum">    1032</span>              :       /*</span>
<span id="L1033"><span class="lineNum">    1033</span>              :        * @brief  Returns the bucket index of a given element.</span>
<span id="L1034"><span class="lineNum">    1034</span>              :        * @param  __key  A key instance.</span>
<span id="L1035"><span class="lineNum">    1035</span>              :        * @return  The key bucket index.</span>
<span id="L1036"><span class="lineNum">    1036</span>              :        */</span>
<span id="L1037"><span class="lineNum">    1037</span>              :       size_type</span>
<span id="L1038"><span class="lineNum">    1038</span>              :       bucket(const key_type&amp; __key) const</span>
<span id="L1039"><span class="lineNum">    1039</span>              :       { return _M_h.bucket(__key); }</span>
<span id="L1040"><span class="lineNum">    1040</span>              :       </span>
<span id="L1041"><span class="lineNum">    1041</span>              :       /**</span>
<span id="L1042"><span class="lineNum">    1042</span>              :        *  @brief  Returns a read/write iterator pointing to the first bucket</span>
<span id="L1043"><span class="lineNum">    1043</span>              :        *         element.</span>
<span id="L1044"><span class="lineNum">    1044</span>              :        *  @param  __n The bucket index.</span>
<span id="L1045"><span class="lineNum">    1045</span>              :        *  @return  A read/write local iterator.</span>
<span id="L1046"><span class="lineNum">    1046</span>              :        */</span>
<span id="L1047"><span class="lineNum">    1047</span>              :       local_iterator</span>
<span id="L1048"><span class="lineNum">    1048</span>              :       begin(size_type __n)</span>
<span id="L1049"><span class="lineNum">    1049</span>              :       { return _M_h.begin(__n); }</span>
<span id="L1050"><span class="lineNum">    1050</span>              : </span>
<span id="L1051"><span class="lineNum">    1051</span>              :       ///@{</span>
<span id="L1052"><span class="lineNum">    1052</span>              :       /**</span>
<span id="L1053"><span class="lineNum">    1053</span>              :        *  @brief  Returns a read-only (constant) iterator pointing to the first</span>
<span id="L1054"><span class="lineNum">    1054</span>              :        *         bucket element.</span>
<span id="L1055"><span class="lineNum">    1055</span>              :        *  @param  __n The bucket index.</span>
<span id="L1056"><span class="lineNum">    1056</span>              :        *  @return  A read-only local iterator.</span>
<span id="L1057"><span class="lineNum">    1057</span>              :        */</span>
<span id="L1058"><span class="lineNum">    1058</span>              :       const_local_iterator</span>
<span id="L1059"><span class="lineNum">    1059</span>              :       begin(size_type __n) const</span>
<span id="L1060"><span class="lineNum">    1060</span>              :       { return _M_h.begin(__n); }</span>
<span id="L1061"><span class="lineNum">    1061</span>              : </span>
<span id="L1062"><span class="lineNum">    1062</span>              :       const_local_iterator</span>
<span id="L1063"><span class="lineNum">    1063</span>              :       cbegin(size_type __n) const</span>
<span id="L1064"><span class="lineNum">    1064</span>              :       { return _M_h.cbegin(__n); }</span>
<span id="L1065"><span class="lineNum">    1065</span>              :       ///@}</span>
<span id="L1066"><span class="lineNum">    1066</span>              : </span>
<span id="L1067"><span class="lineNum">    1067</span>              :       /**</span>
<span id="L1068"><span class="lineNum">    1068</span>              :        *  @brief  Returns a read/write iterator pointing to one past the last</span>
<span id="L1069"><span class="lineNum">    1069</span>              :        *         bucket elements.</span>
<span id="L1070"><span class="lineNum">    1070</span>              :        *  @param  __n The bucket index.</span>
<span id="L1071"><span class="lineNum">    1071</span>              :        *  @return  A read/write local iterator.</span>
<span id="L1072"><span class="lineNum">    1072</span>              :        */</span>
<span id="L1073"><span class="lineNum">    1073</span>              :       local_iterator</span>
<span id="L1074"><span class="lineNum">    1074</span>              :       end(size_type __n)</span>
<span id="L1075"><span class="lineNum">    1075</span>              :       { return _M_h.end(__n); }</span>
<span id="L1076"><span class="lineNum">    1076</span>              : </span>
<span id="L1077"><span class="lineNum">    1077</span>              :       ///@{</span>
<span id="L1078"><span class="lineNum">    1078</span>              :       /**</span>
<span id="L1079"><span class="lineNum">    1079</span>              :        *  @brief  Returns a read-only (constant) iterator pointing to one past</span>
<span id="L1080"><span class="lineNum">    1080</span>              :        *         the last bucket elements.</span>
<span id="L1081"><span class="lineNum">    1081</span>              :        *  @param  __n The bucket index.</span>
<span id="L1082"><span class="lineNum">    1082</span>              :        *  @return  A read-only local iterator.</span>
<span id="L1083"><span class="lineNum">    1083</span>              :        */</span>
<span id="L1084"><span class="lineNum">    1084</span>              :       const_local_iterator</span>
<span id="L1085"><span class="lineNum">    1085</span>              :       end(size_type __n) const</span>
<span id="L1086"><span class="lineNum">    1086</span>              :       { return _M_h.end(__n); }</span>
<span id="L1087"><span class="lineNum">    1087</span>              : </span>
<span id="L1088"><span class="lineNum">    1088</span>              :       const_local_iterator</span>
<span id="L1089"><span class="lineNum">    1089</span>              :       cend(size_type __n) const</span>
<span id="L1090"><span class="lineNum">    1090</span>              :       { return _M_h.cend(__n); }</span>
<span id="L1091"><span class="lineNum">    1091</span>              :       ///@}</span>
<span id="L1092"><span class="lineNum">    1092</span>              : </span>
<span id="L1093"><span class="lineNum">    1093</span>              :       // hash policy.</span>
<span id="L1094"><span class="lineNum">    1094</span>              : </span>
<span id="L1095"><span class="lineNum">    1095</span>              :       /// Returns the average number of elements per bucket.</span>
<span id="L1096"><span class="lineNum">    1096</span>              :       float</span>
<span id="L1097"><span class="lineNum">    1097</span>              :       load_factor() const noexcept</span>
<span id="L1098"><span class="lineNum">    1098</span>              :       { return _M_h.load_factor(); }</span>
<span id="L1099"><span class="lineNum">    1099</span>              : </span>
<span id="L1100"><span class="lineNum">    1100</span>              :       /// Returns a positive number that the %unordered_map tries to keep the</span>
<span id="L1101"><span class="lineNum">    1101</span>              :       /// load factor less than or equal to.</span>
<span id="L1102"><span class="lineNum">    1102</span>              :       float</span>
<span id="L1103"><span class="lineNum">    1103</span>              :       max_load_factor() const noexcept</span>
<span id="L1104"><span class="lineNum">    1104</span>              :       { return _M_h.max_load_factor(); }</span>
<span id="L1105"><span class="lineNum">    1105</span>              : </span>
<span id="L1106"><span class="lineNum">    1106</span>              :       /**</span>
<span id="L1107"><span class="lineNum">    1107</span>              :        *  @brief  Change the %unordered_map maximum load factor.</span>
<span id="L1108"><span class="lineNum">    1108</span>              :        *  @param  __z The new maximum load factor.</span>
<span id="L1109"><span class="lineNum">    1109</span>              :        */</span>
<span id="L1110"><span class="lineNum">    1110</span>              :       void</span>
<span id="L1111"><span class="lineNum">    1111</span>              :       max_load_factor(float __z)</span>
<span id="L1112"><span class="lineNum">    1112</span>              :       { _M_h.max_load_factor(__z); }</span>
<span id="L1113"><span class="lineNum">    1113</span>              : </span>
<span id="L1114"><span class="lineNum">    1114</span>              :       /**</span>
<span id="L1115"><span class="lineNum">    1115</span>              :        *  @brief  May rehash the %unordered_map.</span>
<span id="L1116"><span class="lineNum">    1116</span>              :        *  @param  __n The new number of buckets.</span>
<span id="L1117"><span class="lineNum">    1117</span>              :        *</span>
<span id="L1118"><span class="lineNum">    1118</span>              :        *  Rehash will occur only if the new number of buckets respect the</span>
<span id="L1119"><span class="lineNum">    1119</span>              :        *  %unordered_map maximum load factor.</span>
<span id="L1120"><span class="lineNum">    1120</span>              :        */</span>
<span id="L1121"><span class="lineNum">    1121</span>              :       void</span>
<span id="L1122"><span class="lineNum">    1122</span>              :       rehash(size_type __n)</span>
<span id="L1123"><span class="lineNum">    1123</span>              :       { _M_h.rehash(__n); }</span>
<span id="L1124"><span class="lineNum">    1124</span>              : </span>
<span id="L1125"><span class="lineNum">    1125</span>              :       /**</span>
<span id="L1126"><span class="lineNum">    1126</span>              :        *  @brief  Prepare the %unordered_map for a specified number of</span>
<span id="L1127"><span class="lineNum">    1127</span>              :        *          elements.</span>
<span id="L1128"><span class="lineNum">    1128</span>              :        *  @param  __n Number of elements required.</span>
<span id="L1129"><span class="lineNum">    1129</span>              :        *</span>
<span id="L1130"><span class="lineNum">    1130</span>              :        *  Same as rehash(ceil(n / max_load_factor())).</span>
<span id="L1131"><span class="lineNum">    1131</span>              :        */</span>
<span id="L1132"><span class="lineNum">    1132</span>              :       void</span>
<span id="L1133"><span class="lineNum">    1133</span>              :       reserve(size_type __n)</span>
<span id="L1134"><span class="lineNum">    1134</span>              :       { _M_h.reserve(__n); }</span>
<span id="L1135"><span class="lineNum">    1135</span>              : </span>
<span id="L1136"><span class="lineNum">    1136</span>              :       template&lt;typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,</span>
<span id="L1137"><span class="lineNum">    1137</span>              :                typename _Alloc1&gt;</span>
<span id="L1138"><span class="lineNum">    1138</span>              :         friend bool</span>
<span id="L1139"><span class="lineNum">    1139</span>              :         operator==(const unordered_map&lt;_Key1, _Tp1, _Hash1, _Pred1, _Alloc1&gt;&amp;,</span>
<span id="L1140"><span class="lineNum">    1140</span>              :                    const unordered_map&lt;_Key1, _Tp1, _Hash1, _Pred1, _Alloc1&gt;&amp;);</span>
<span id="L1141"><span class="lineNum">    1141</span>              :     };</span>
<span id="L1142"><span class="lineNum">    1142</span>              : </span>
<span id="L1143"><span class="lineNum">    1143</span>              : #if __cpp_deduction_guides &gt;= 201606</span>
<span id="L1144"><span class="lineNum">    1144</span>              : </span>
<span id="L1145"><span class="lineNum">    1145</span>              :   template&lt;typename _InputIterator,</span>
<span id="L1146"><span class="lineNum">    1146</span>              :            typename _Hash = hash&lt;__iter_key_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L1147"><span class="lineNum">    1147</span>              :            typename _Pred = equal_to&lt;__iter_key_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L1148"><span class="lineNum">    1148</span>              :            typename _Allocator = allocator&lt;__iter_to_alloc_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L1149"><span class="lineNum">    1149</span>              :            typename = _RequireInputIter&lt;_InputIterator&gt;,</span>
<span id="L1150"><span class="lineNum">    1150</span>              :            typename = _RequireNotAllocatorOrIntegral&lt;_Hash&gt;,</span>
<span id="L1151"><span class="lineNum">    1151</span>              :            typename = _RequireNotAllocator&lt;_Pred&gt;,</span>
<span id="L1152"><span class="lineNum">    1152</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L1153"><span class="lineNum">    1153</span>              :     unordered_map(_InputIterator, _InputIterator,</span>
<span id="L1154"><span class="lineNum">    1154</span>              :                   typename unordered_map&lt;int, int&gt;::size_type = {},</span>
<span id="L1155"><span class="lineNum">    1155</span>              :                   _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())</span>
<span id="L1156"><span class="lineNum">    1156</span>              :     -&gt; unordered_map&lt;__iter_key_t&lt;_InputIterator&gt;,</span>
<span id="L1157"><span class="lineNum">    1157</span>              :                      __iter_val_t&lt;_InputIterator&gt;,</span>
<span id="L1158"><span class="lineNum">    1158</span>              :                      _Hash, _Pred, _Allocator&gt;;</span>
<span id="L1159"><span class="lineNum">    1159</span>              : </span>
<span id="L1160"><span class="lineNum">    1160</span>              :   template&lt;typename _Key, typename _Tp, typename _Hash = hash&lt;_Key&gt;,</span>
<span id="L1161"><span class="lineNum">    1161</span>              :            typename _Pred = equal_to&lt;_Key&gt;,</span>
<span id="L1162"><span class="lineNum">    1162</span>              :            typename _Allocator = allocator&lt;pair&lt;const _Key, _Tp&gt;&gt;,</span>
<span id="L1163"><span class="lineNum">    1163</span>              :            typename = _RequireNotAllocatorOrIntegral&lt;_Hash&gt;,</span>
<span id="L1164"><span class="lineNum">    1164</span>              :            typename = _RequireNotAllocator&lt;_Pred&gt;,</span>
<span id="L1165"><span class="lineNum">    1165</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L1166"><span class="lineNum">    1166</span>              :     unordered_map(initializer_list&lt;pair&lt;_Key, _Tp&gt;&gt;,</span>
<span id="L1167"><span class="lineNum">    1167</span>              :                   typename unordered_map&lt;int, int&gt;::size_type = {},</span>
<span id="L1168"><span class="lineNum">    1168</span>              :                   _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())</span>
<span id="L1169"><span class="lineNum">    1169</span>              :     -&gt; unordered_map&lt;_Key, _Tp, _Hash, _Pred, _Allocator&gt;;</span>
<span id="L1170"><span class="lineNum">    1170</span>              : </span>
<span id="L1171"><span class="lineNum">    1171</span>              :   template&lt;typename _InputIterator, typename _Allocator,</span>
<span id="L1172"><span class="lineNum">    1172</span>              :            typename = _RequireInputIter&lt;_InputIterator&gt;,</span>
<span id="L1173"><span class="lineNum">    1173</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L1174"><span class="lineNum">    1174</span>              :     unordered_map(_InputIterator, _InputIterator,</span>
<span id="L1175"><span class="lineNum">    1175</span>              :                   typename unordered_map&lt;int, int&gt;::size_type, _Allocator)</span>
<span id="L1176"><span class="lineNum">    1176</span>              :     -&gt; unordered_map&lt;__iter_key_t&lt;_InputIterator&gt;,</span>
<span id="L1177"><span class="lineNum">    1177</span>              :                      __iter_val_t&lt;_InputIterator&gt;,</span>
<span id="L1178"><span class="lineNum">    1178</span>              :                      hash&lt;__iter_key_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L1179"><span class="lineNum">    1179</span>              :                      equal_to&lt;__iter_key_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L1180"><span class="lineNum">    1180</span>              :                      _Allocator&gt;;</span>
<span id="L1181"><span class="lineNum">    1181</span>              : </span>
<span id="L1182"><span class="lineNum">    1182</span>              :   template&lt;typename _InputIterator, typename _Allocator,</span>
<span id="L1183"><span class="lineNum">    1183</span>              :            typename = _RequireInputIter&lt;_InputIterator&gt;,</span>
<span id="L1184"><span class="lineNum">    1184</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L1185"><span class="lineNum">    1185</span>              :     unordered_map(_InputIterator, _InputIterator, _Allocator)</span>
<span id="L1186"><span class="lineNum">    1186</span>              :     -&gt; unordered_map&lt;__iter_key_t&lt;_InputIterator&gt;,</span>
<span id="L1187"><span class="lineNum">    1187</span>              :                      __iter_val_t&lt;_InputIterator&gt;,</span>
<span id="L1188"><span class="lineNum">    1188</span>              :                      hash&lt;__iter_key_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L1189"><span class="lineNum">    1189</span>              :                      equal_to&lt;__iter_key_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L1190"><span class="lineNum">    1190</span>              :                      _Allocator&gt;;</span>
<span id="L1191"><span class="lineNum">    1191</span>              : </span>
<span id="L1192"><span class="lineNum">    1192</span>              :   template&lt;typename _InputIterator, typename _Hash, typename _Allocator,</span>
<span id="L1193"><span class="lineNum">    1193</span>              :            typename = _RequireInputIter&lt;_InputIterator&gt;,</span>
<span id="L1194"><span class="lineNum">    1194</span>              :            typename = _RequireNotAllocatorOrIntegral&lt;_Hash&gt;,</span>
<span id="L1195"><span class="lineNum">    1195</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L1196"><span class="lineNum">    1196</span>              :     unordered_map(_InputIterator, _InputIterator,</span>
<span id="L1197"><span class="lineNum">    1197</span>              :                   typename unordered_map&lt;int, int&gt;::size_type,</span>
<span id="L1198"><span class="lineNum">    1198</span>              :                   _Hash, _Allocator)</span>
<span id="L1199"><span class="lineNum">    1199</span>              :     -&gt; unordered_map&lt;__iter_key_t&lt;_InputIterator&gt;,</span>
<span id="L1200"><span class="lineNum">    1200</span>              :                      __iter_val_t&lt;_InputIterator&gt;, _Hash,</span>
<span id="L1201"><span class="lineNum">    1201</span>              :                      equal_to&lt;__iter_key_t&lt;_InputIterator&gt;&gt;, _Allocator&gt;;</span>
<span id="L1202"><span class="lineNum">    1202</span>              : </span>
<span id="L1203"><span class="lineNum">    1203</span>              :   template&lt;typename _Key, typename _Tp, typename _Allocator,</span>
<span id="L1204"><span class="lineNum">    1204</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L1205"><span class="lineNum">    1205</span>              :     unordered_map(initializer_list&lt;pair&lt;_Key, _Tp&gt;&gt;,</span>
<span id="L1206"><span class="lineNum">    1206</span>              :                   typename unordered_map&lt;int, int&gt;::size_type,</span>
<span id="L1207"><span class="lineNum">    1207</span>              :                   _Allocator)</span>
<span id="L1208"><span class="lineNum">    1208</span>              :     -&gt; unordered_map&lt;_Key, _Tp, hash&lt;_Key&gt;, equal_to&lt;_Key&gt;, _Allocator&gt;;</span>
<span id="L1209"><span class="lineNum">    1209</span>              : </span>
<span id="L1210"><span class="lineNum">    1210</span>              :   template&lt;typename _Key, typename _Tp, typename _Allocator,</span>
<span id="L1211"><span class="lineNum">    1211</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L1212"><span class="lineNum">    1212</span>              :     unordered_map(initializer_list&lt;pair&lt;_Key, _Tp&gt;&gt;, _Allocator)</span>
<span id="L1213"><span class="lineNum">    1213</span>              :     -&gt; unordered_map&lt;_Key, _Tp, hash&lt;_Key&gt;, equal_to&lt;_Key&gt;, _Allocator&gt;;</span>
<span id="L1214"><span class="lineNum">    1214</span>              : </span>
<span id="L1215"><span class="lineNum">    1215</span>              :   template&lt;typename _Key, typename _Tp, typename _Hash, typename _Allocator,</span>
<span id="L1216"><span class="lineNum">    1216</span>              :            typename = _RequireNotAllocatorOrIntegral&lt;_Hash&gt;,</span>
<span id="L1217"><span class="lineNum">    1217</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L1218"><span class="lineNum">    1218</span>              :     unordered_map(initializer_list&lt;pair&lt;_Key, _Tp&gt;&gt;,</span>
<span id="L1219"><span class="lineNum">    1219</span>              :                   typename unordered_map&lt;int, int&gt;::size_type,</span>
<span id="L1220"><span class="lineNum">    1220</span>              :                   _Hash, _Allocator)</span>
<span id="L1221"><span class="lineNum">    1221</span>              :     -&gt; unordered_map&lt;_Key, _Tp, _Hash, equal_to&lt;_Key&gt;, _Allocator&gt;;</span>
<span id="L1222"><span class="lineNum">    1222</span>              : </span>
<span id="L1223"><span class="lineNum">    1223</span>              : #endif</span>
<span id="L1224"><span class="lineNum">    1224</span>              : </span>
<span id="L1225"><span class="lineNum">    1225</span>              :   /**</span>
<span id="L1226"><span class="lineNum">    1226</span>              :    *  @brief A standard container composed of equivalent keys</span>
<span id="L1227"><span class="lineNum">    1227</span>              :    *  (possibly containing multiple of each key value) that associates</span>
<span id="L1228"><span class="lineNum">    1228</span>              :    *  values of another type with the keys.</span>
<span id="L1229"><span class="lineNum">    1229</span>              :    *</span>
<span id="L1230"><span class="lineNum">    1230</span>              :    *  @ingroup unordered_associative_containers</span>
<span id="L1231"><span class="lineNum">    1231</span>              :    *  @headerfile unordered_map</span>
<span id="L1232"><span class="lineNum">    1232</span>              :    *  @since C++11</span>
<span id="L1233"><span class="lineNum">    1233</span>              :    *</span>
<span id="L1234"><span class="lineNum">    1234</span>              :    *  @tparam  _Key    Type of key objects.</span>
<span id="L1235"><span class="lineNum">    1235</span>              :    *  @tparam  _Tp     Type of mapped objects.</span>
<span id="L1236"><span class="lineNum">    1236</span>              :    *  @tparam  _Hash   Hashing function object type, defaults to hash&lt;_Value&gt;.</span>
<span id="L1237"><span class="lineNum">    1237</span>              :    *  @tparam  _Pred   Predicate function object type, defaults</span>
<span id="L1238"><span class="lineNum">    1238</span>              :    *                   to equal_to&lt;_Value&gt;.</span>
<span id="L1239"><span class="lineNum">    1239</span>              :    *  @tparam  _Alloc  Allocator type, defaults to</span>
<span id="L1240"><span class="lineNum">    1240</span>              :    *                   std::allocator&lt;std::pair&lt;const _Key, _Tp&gt;&gt;.</span>
<span id="L1241"><span class="lineNum">    1241</span>              :    *</span>
<span id="L1242"><span class="lineNum">    1242</span>              :    *  Meets the requirements of a &lt;a href=&quot;tables.html#65&quot;&gt;container&lt;/a&gt;, and</span>
<span id="L1243"><span class="lineNum">    1243</span>              :    *  &lt;a href=&quot;tables.html#xx&quot;&gt;unordered associative container&lt;/a&gt;</span>
<span id="L1244"><span class="lineNum">    1244</span>              :    *</span>
<span id="L1245"><span class="lineNum">    1245</span>              :    * The resulting value type of the container is std::pair&lt;const _Key, _Tp&gt;.</span>
<span id="L1246"><span class="lineNum">    1246</span>              :    *</span>
<span id="L1247"><span class="lineNum">    1247</span>              :    *  Base is _Hashtable, dispatched at compile time via template</span>
<span id="L1248"><span class="lineNum">    1248</span>              :    *  alias __ummap_hashtable.</span>
<span id="L1249"><span class="lineNum">    1249</span>              :    */</span>
<span id="L1250"><span class="lineNum">    1250</span>              :   template&lt;typename _Key, typename _Tp,</span>
<span id="L1251"><span class="lineNum">    1251</span>              :            typename _Hash = hash&lt;_Key&gt;,</span>
<span id="L1252"><span class="lineNum">    1252</span>              :            typename _Pred = equal_to&lt;_Key&gt;,</span>
<span id="L1253"><span class="lineNum">    1253</span>              :            typename _Alloc = allocator&lt;std::pair&lt;const _Key, _Tp&gt;&gt;&gt;</span>
<span id="L1254"><span class="lineNum">    1254</span>              :     class unordered_multimap</span>
<span id="L1255"><span class="lineNum">    1255</span>              :     {</span>
<span id="L1256"><span class="lineNum">    1256</span>              :       typedef __ummap_hashtable&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;  _Hashtable;</span>
<span id="L1257"><span class="lineNum">    1257</span>              :       _Hashtable _M_h;</span>
<span id="L1258"><span class="lineNum">    1258</span>              : </span>
<span id="L1259"><span class="lineNum">    1259</span>              :     public:</span>
<span id="L1260"><span class="lineNum">    1260</span>              :       // typedefs:</span>
<span id="L1261"><span class="lineNum">    1261</span>              :       ///@{</span>
<span id="L1262"><span class="lineNum">    1262</span>              :       /// Public typedefs.</span>
<span id="L1263"><span class="lineNum">    1263</span>              :       typedef typename _Hashtable::key_type     key_type;</span>
<span id="L1264"><span class="lineNum">    1264</span>              :       typedef typename _Hashtable::value_type   value_type;</span>
<span id="L1265"><span class="lineNum">    1265</span>              :       typedef typename _Hashtable::mapped_type  mapped_type;</span>
<span id="L1266"><span class="lineNum">    1266</span>              :       typedef typename _Hashtable::hasher       hasher;</span>
<span id="L1267"><span class="lineNum">    1267</span>              :       typedef typename _Hashtable::key_equal    key_equal;</span>
<span id="L1268"><span class="lineNum">    1268</span>              :       typedef typename _Hashtable::allocator_type allocator_type;</span>
<span id="L1269"><span class="lineNum">    1269</span>              :       ///@}</span>
<span id="L1270"><span class="lineNum">    1270</span>              : </span>
<span id="L1271"><span class="lineNum">    1271</span>              :       ///@{</span>
<span id="L1272"><span class="lineNum">    1272</span>              :       ///  Iterator-related typedefs.</span>
<span id="L1273"><span class="lineNum">    1273</span>              :       typedef typename _Hashtable::pointer              pointer;</span>
<span id="L1274"><span class="lineNum">    1274</span>              :       typedef typename _Hashtable::const_pointer        const_pointer;</span>
<span id="L1275"><span class="lineNum">    1275</span>              :       typedef typename _Hashtable::reference            reference;</span>
<span id="L1276"><span class="lineNum">    1276</span>              :       typedef typename _Hashtable::const_reference      const_reference;</span>
<span id="L1277"><span class="lineNum">    1277</span>              :       typedef typename _Hashtable::iterator             iterator;</span>
<span id="L1278"><span class="lineNum">    1278</span>              :       typedef typename _Hashtable::const_iterator       const_iterator;</span>
<span id="L1279"><span class="lineNum">    1279</span>              :       typedef typename _Hashtable::local_iterator       local_iterator;</span>
<span id="L1280"><span class="lineNum">    1280</span>              :       typedef typename _Hashtable::const_local_iterator const_local_iterator;</span>
<span id="L1281"><span class="lineNum">    1281</span>              :       typedef typename _Hashtable::size_type            size_type;</span>
<span id="L1282"><span class="lineNum">    1282</span>              :       typedef typename _Hashtable::difference_type      difference_type;</span>
<span id="L1283"><span class="lineNum">    1283</span>              :       ///@}</span>
<span id="L1284"><span class="lineNum">    1284</span>              : </span>
<span id="L1285"><span class="lineNum">    1285</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L1286"><span class="lineNum">    1286</span>              :       using node_type = typename _Hashtable::node_type;</span>
<span id="L1287"><span class="lineNum">    1287</span>              : #endif</span>
<span id="L1288"><span class="lineNum">    1288</span>              : </span>
<span id="L1289"><span class="lineNum">    1289</span>              :       //construct/destroy/copy</span>
<span id="L1290"><span class="lineNum">    1290</span>              : </span>
<span id="L1291"><span class="lineNum">    1291</span>              :       /// Default constructor.</span>
<span id="L1292"><span class="lineNum">    1292</span>              :       unordered_multimap() = default;</span>
<span id="L1293"><span class="lineNum">    1293</span>              : </span>
<span id="L1294"><span class="lineNum">    1294</span>              :       /**</span>
<span id="L1295"><span class="lineNum">    1295</span>              :        *  @brief  Default constructor creates no elements.</span>
<span id="L1296"><span class="lineNum">    1296</span>              :        *  @param __n  Mnimal initial number of buckets.</span>
<span id="L1297"><span class="lineNum">    1297</span>              :        *  @param __hf  A hash functor.</span>
<span id="L1298"><span class="lineNum">    1298</span>              :        *  @param __eql  A key equality functor.</span>
<span id="L1299"><span class="lineNum">    1299</span>              :        *  @param __a  An allocator object.</span>
<span id="L1300"><span class="lineNum">    1300</span>              :        */</span>
<span id="L1301"><span class="lineNum">    1301</span>              :       explicit</span>
<span id="L1302"><span class="lineNum">    1302</span>              :       unordered_multimap(size_type __n,</span>
<span id="L1303"><span class="lineNum">    1303</span>              :                          const hasher&amp; __hf = hasher(),</span>
<span id="L1304"><span class="lineNum">    1304</span>              :                          const key_equal&amp; __eql = key_equal(),</span>
<span id="L1305"><span class="lineNum">    1305</span>              :                          const allocator_type&amp; __a = allocator_type())</span>
<span id="L1306"><span class="lineNum">    1306</span>              :       : _M_h(__n, __hf, __eql, __a)</span>
<span id="L1307"><span class="lineNum">    1307</span>              :       { }</span>
<span id="L1308"><span class="lineNum">    1308</span>              : </span>
<span id="L1309"><span class="lineNum">    1309</span>              :       /**</span>
<span id="L1310"><span class="lineNum">    1310</span>              :        *  @brief  Builds an %unordered_multimap from a range.</span>
<span id="L1311"><span class="lineNum">    1311</span>              :        *  @param  __first An input iterator.</span>
<span id="L1312"><span class="lineNum">    1312</span>              :        *  @param  __last  An input iterator.</span>
<span id="L1313"><span class="lineNum">    1313</span>              :        *  @param __n      Minimal initial number of buckets.</span>
<span id="L1314"><span class="lineNum">    1314</span>              :        *  @param __hf     A hash functor.</span>
<span id="L1315"><span class="lineNum">    1315</span>              :        *  @param __eql    A key equality functor.</span>
<span id="L1316"><span class="lineNum">    1316</span>              :        *  @param __a      An allocator object.</span>
<span id="L1317"><span class="lineNum">    1317</span>              :        *</span>
<span id="L1318"><span class="lineNum">    1318</span>              :        *  Create an %unordered_multimap consisting of copies of the elements</span>
<span id="L1319"><span class="lineNum">    1319</span>              :        *  from [__first,__last).  This is linear in N (where N is</span>
<span id="L1320"><span class="lineNum">    1320</span>              :        *  distance(__first,__last)).</span>
<span id="L1321"><span class="lineNum">    1321</span>              :        */</span>
<span id="L1322"><span class="lineNum">    1322</span>              :       template&lt;typename _InputIterator&gt;</span>
<span id="L1323"><span class="lineNum">    1323</span>              :         unordered_multimap(_InputIterator __first, _InputIterator __last,</span>
<span id="L1324"><span class="lineNum">    1324</span>              :                            size_type __n = 0,</span>
<span id="L1325"><span class="lineNum">    1325</span>              :                            const hasher&amp; __hf = hasher(),</span>
<span id="L1326"><span class="lineNum">    1326</span>              :                            const key_equal&amp; __eql = key_equal(),</span>
<span id="L1327"><span class="lineNum">    1327</span>              :                            const allocator_type&amp; __a = allocator_type())</span>
<span id="L1328"><span class="lineNum">    1328</span>              :         : _M_h(__first, __last, __n, __hf, __eql, __a)</span>
<span id="L1329"><span class="lineNum">    1329</span>              :         { }</span>
<span id="L1330"><span class="lineNum">    1330</span>              : </span>
<span id="L1331"><span class="lineNum">    1331</span>              :       /// Copy constructor.</span>
<span id="L1332"><span class="lineNum">    1332</span>              :       unordered_multimap(const unordered_multimap&amp;) = default;</span>
<span id="L1333"><span class="lineNum">    1333</span>              : </span>
<span id="L1334"><span class="lineNum">    1334</span>              :       /// Move constructor.</span>
<span id="L1335"><span class="lineNum">    1335</span>              :       unordered_multimap(unordered_multimap&amp;&amp;) = default;</span>
<span id="L1336"><span class="lineNum">    1336</span>              : </span>
<span id="L1337"><span class="lineNum">    1337</span>              :       /**</span>
<span id="L1338"><span class="lineNum">    1338</span>              :        *  @brief Creates an %unordered_multimap with no elements.</span>
<span id="L1339"><span class="lineNum">    1339</span>              :        *  @param __a An allocator object.</span>
<span id="L1340"><span class="lineNum">    1340</span>              :        */</span>
<span id="L1341"><span class="lineNum">    1341</span>              :       explicit</span>
<span id="L1342"><span class="lineNum">    1342</span>              :       unordered_multimap(const allocator_type&amp; __a)</span>
<span id="L1343"><span class="lineNum">    1343</span>              :       : _M_h(__a)</span>
<span id="L1344"><span class="lineNum">    1344</span>              :       { }</span>
<span id="L1345"><span class="lineNum">    1345</span>              : </span>
<span id="L1346"><span class="lineNum">    1346</span>              :       /*</span>
<span id="L1347"><span class="lineNum">    1347</span>              :        *  @brief Copy constructor with allocator argument.</span>
<span id="L1348"><span class="lineNum">    1348</span>              :        * @param  __uset  Input %unordered_multimap to copy.</span>
<span id="L1349"><span class="lineNum">    1349</span>              :        * @param  __a  An allocator object.</span>
<span id="L1350"><span class="lineNum">    1350</span>              :        */</span>
<span id="L1351"><span class="lineNum">    1351</span>              :       unordered_multimap(const unordered_multimap&amp; __ummap,</span>
<span id="L1352"><span class="lineNum">    1352</span>              :                          const allocator_type&amp; __a)</span>
<span id="L1353"><span class="lineNum">    1353</span>              :       : _M_h(__ummap._M_h, __a)</span>
<span id="L1354"><span class="lineNum">    1354</span>              :       { }</span>
<span id="L1355"><span class="lineNum">    1355</span>              : </span>
<span id="L1356"><span class="lineNum">    1356</span>              :       /*</span>
<span id="L1357"><span class="lineNum">    1357</span>              :        *  @brief  Move constructor with allocator argument.</span>
<span id="L1358"><span class="lineNum">    1358</span>              :        *  @param  __uset Input %unordered_multimap to move.</span>
<span id="L1359"><span class="lineNum">    1359</span>              :        *  @param  __a    An allocator object.</span>
<span id="L1360"><span class="lineNum">    1360</span>              :        */</span>
<span id="L1361"><span class="lineNum">    1361</span>              :       unordered_multimap(unordered_multimap&amp;&amp; __ummap,</span>
<span id="L1362"><span class="lineNum">    1362</span>              :                          const allocator_type&amp; __a)</span>
<span id="L1363"><span class="lineNum">    1363</span>              :         noexcept( noexcept(_Hashtable(std::move(__ummap._M_h), __a)) )</span>
<span id="L1364"><span class="lineNum">    1364</span>              :       : _M_h(std::move(__ummap._M_h), __a)</span>
<span id="L1365"><span class="lineNum">    1365</span>              :       { }</span>
<span id="L1366"><span class="lineNum">    1366</span>              : </span>
<span id="L1367"><span class="lineNum">    1367</span>              :       /**</span>
<span id="L1368"><span class="lineNum">    1368</span>              :        *  @brief  Builds an %unordered_multimap from an initializer_list.</span>
<span id="L1369"><span class="lineNum">    1369</span>              :        *  @param  __l  An initializer_list.</span>
<span id="L1370"><span class="lineNum">    1370</span>              :        *  @param __n  Minimal initial number of buckets.</span>
<span id="L1371"><span class="lineNum">    1371</span>              :        *  @param __hf  A hash functor.</span>
<span id="L1372"><span class="lineNum">    1372</span>              :        *  @param __eql  A key equality functor.</span>
<span id="L1373"><span class="lineNum">    1373</span>              :        *  @param  __a  An allocator object.</span>
<span id="L1374"><span class="lineNum">    1374</span>              :        *</span>
<span id="L1375"><span class="lineNum">    1375</span>              :        *  Create an %unordered_multimap consisting of copies of the elements in</span>
<span id="L1376"><span class="lineNum">    1376</span>              :        *  the list. This is linear in N (where N is @a __l.size()).</span>
<span id="L1377"><span class="lineNum">    1377</span>              :        */</span>
<span id="L1378"><span class="lineNum">    1378</span>              :       unordered_multimap(initializer_list&lt;value_type&gt; __l,</span>
<span id="L1379"><span class="lineNum">    1379</span>              :                          size_type __n = 0,</span>
<span id="L1380"><span class="lineNum">    1380</span>              :                          const hasher&amp; __hf = hasher(),</span>
<span id="L1381"><span class="lineNum">    1381</span>              :                          const key_equal&amp; __eql = key_equal(),</span>
<span id="L1382"><span class="lineNum">    1382</span>              :                          const allocator_type&amp; __a = allocator_type())</span>
<span id="L1383"><span class="lineNum">    1383</span>              :       : _M_h(__l, __n, __hf, __eql, __a)</span>
<span id="L1384"><span class="lineNum">    1384</span>              :       { }</span>
<span id="L1385"><span class="lineNum">    1385</span>              : </span>
<span id="L1386"><span class="lineNum">    1386</span>              :       unordered_multimap(size_type __n, const allocator_type&amp; __a)</span>
<span id="L1387"><span class="lineNum">    1387</span>              :       : unordered_multimap(__n, hasher(), key_equal(), __a)</span>
<span id="L1388"><span class="lineNum">    1388</span>              :       { }</span>
<span id="L1389"><span class="lineNum">    1389</span>              : </span>
<span id="L1390"><span class="lineNum">    1390</span>              :       unordered_multimap(size_type __n, const hasher&amp; __hf,</span>
<span id="L1391"><span class="lineNum">    1391</span>              :                          const allocator_type&amp; __a)</span>
<span id="L1392"><span class="lineNum">    1392</span>              :       : unordered_multimap(__n, __hf, key_equal(), __a)</span>
<span id="L1393"><span class="lineNum">    1393</span>              :       { }</span>
<span id="L1394"><span class="lineNum">    1394</span>              : </span>
<span id="L1395"><span class="lineNum">    1395</span>              :       template&lt;typename _InputIterator&gt;</span>
<span id="L1396"><span class="lineNum">    1396</span>              :         unordered_multimap(_InputIterator __first, _InputIterator __last,</span>
<span id="L1397"><span class="lineNum">    1397</span>              :                            size_type __n,</span>
<span id="L1398"><span class="lineNum">    1398</span>              :                            const allocator_type&amp; __a)</span>
<span id="L1399"><span class="lineNum">    1399</span>              :         : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)</span>
<span id="L1400"><span class="lineNum">    1400</span>              :         { }</span>
<span id="L1401"><span class="lineNum">    1401</span>              : </span>
<span id="L1402"><span class="lineNum">    1402</span>              :       template&lt;typename _InputIterator&gt;</span>
<span id="L1403"><span class="lineNum">    1403</span>              :         unordered_multimap(_InputIterator __first, _InputIterator __last,</span>
<span id="L1404"><span class="lineNum">    1404</span>              :                            size_type __n, const hasher&amp; __hf,</span>
<span id="L1405"><span class="lineNum">    1405</span>              :                            const allocator_type&amp; __a)</span>
<span id="L1406"><span class="lineNum">    1406</span>              :         : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)</span>
<span id="L1407"><span class="lineNum">    1407</span>              :         { }</span>
<span id="L1408"><span class="lineNum">    1408</span>              : </span>
<span id="L1409"><span class="lineNum">    1409</span>              :       unordered_multimap(initializer_list&lt;value_type&gt; __l,</span>
<span id="L1410"><span class="lineNum">    1410</span>              :                          size_type __n,</span>
<span id="L1411"><span class="lineNum">    1411</span>              :                          const allocator_type&amp; __a)</span>
<span id="L1412"><span class="lineNum">    1412</span>              :       : unordered_multimap(__l, __n, hasher(), key_equal(), __a)</span>
<span id="L1413"><span class="lineNum">    1413</span>              :       { }</span>
<span id="L1414"><span class="lineNum">    1414</span>              : </span>
<span id="L1415"><span class="lineNum">    1415</span>              :       unordered_multimap(initializer_list&lt;value_type&gt; __l,</span>
<span id="L1416"><span class="lineNum">    1416</span>              :                          size_type __n, const hasher&amp; __hf,</span>
<span id="L1417"><span class="lineNum">    1417</span>              :                          const allocator_type&amp; __a)</span>
<span id="L1418"><span class="lineNum">    1418</span>              :       : unordered_multimap(__l, __n, __hf, key_equal(), __a)</span>
<span id="L1419"><span class="lineNum">    1419</span>              :       { }</span>
<span id="L1420"><span class="lineNum">    1420</span>              : </span>
<span id="L1421"><span class="lineNum">    1421</span>              :       /// Copy assignment operator.</span>
<span id="L1422"><span class="lineNum">    1422</span>              :       unordered_multimap&amp;</span>
<span id="L1423"><span class="lineNum">    1423</span>              :       operator=(const unordered_multimap&amp;) = default;</span>
<span id="L1424"><span class="lineNum">    1424</span>              : </span>
<span id="L1425"><span class="lineNum">    1425</span>              :       /// Move assignment operator.</span>
<span id="L1426"><span class="lineNum">    1426</span>              :       unordered_multimap&amp;</span>
<span id="L1427"><span class="lineNum">    1427</span>              :       operator=(unordered_multimap&amp;&amp;) = default;</span>
<span id="L1428"><span class="lineNum">    1428</span>              : </span>
<span id="L1429"><span class="lineNum">    1429</span>              :       /**</span>
<span id="L1430"><span class="lineNum">    1430</span>              :        *  @brief  %Unordered_multimap list assignment operator.</span>
<span id="L1431"><span class="lineNum">    1431</span>              :        *  @param  __l  An initializer_list.</span>
<span id="L1432"><span class="lineNum">    1432</span>              :        *</span>
<span id="L1433"><span class="lineNum">    1433</span>              :        *  This function fills an %unordered_multimap with copies of the</span>
<span id="L1434"><span class="lineNum">    1434</span>              :        *  elements in the initializer list @a __l.</span>
<span id="L1435"><span class="lineNum">    1435</span>              :        *</span>
<span id="L1436"><span class="lineNum">    1436</span>              :        *  Note that the assignment completely changes the %unordered_multimap</span>
<span id="L1437"><span class="lineNum">    1437</span>              :        *  and that the resulting %unordered_multimap's size is the same as the</span>
<span id="L1438"><span class="lineNum">    1438</span>              :        *  number of elements assigned.</span>
<span id="L1439"><span class="lineNum">    1439</span>              :        */</span>
<span id="L1440"><span class="lineNum">    1440</span>              :       unordered_multimap&amp;</span>
<span id="L1441"><span class="lineNum">    1441</span>              :       operator=(initializer_list&lt;value_type&gt; __l)</span>
<span id="L1442"><span class="lineNum">    1442</span>              :       {</span>
<span id="L1443"><span class="lineNum">    1443</span>              :         _M_h = __l;</span>
<span id="L1444"><span class="lineNum">    1444</span>              :         return *this;</span>
<span id="L1445"><span class="lineNum">    1445</span>              :       }</span>
<span id="L1446"><span class="lineNum">    1446</span>              : </span>
<span id="L1447"><span class="lineNum">    1447</span>              :       ///  Returns the allocator object used by the %unordered_multimap.</span>
<span id="L1448"><span class="lineNum">    1448</span>              :       allocator_type</span>
<span id="L1449"><span class="lineNum">    1449</span>              :       get_allocator() const noexcept</span>
<span id="L1450"><span class="lineNum">    1450</span>              :       { return _M_h.get_allocator(); }</span>
<span id="L1451"><span class="lineNum">    1451</span>              : </span>
<span id="L1452"><span class="lineNum">    1452</span>              :       // size and capacity:</span>
<span id="L1453"><span class="lineNum">    1453</span>              : </span>
<span id="L1454"><span class="lineNum">    1454</span>              :       ///  Returns true if the %unordered_multimap is empty.</span>
<span id="L1455"><span class="lineNum">    1455</span>              :       _GLIBCXX_NODISCARD bool</span>
<span id="L1456"><span class="lineNum">    1456</span>              :       empty() const noexcept</span>
<span id="L1457"><span class="lineNum">    1457</span>              :       { return _M_h.empty(); }</span>
<span id="L1458"><span class="lineNum">    1458</span>              : </span>
<span id="L1459"><span class="lineNum">    1459</span>              :       ///  Returns the size of the %unordered_multimap.</span>
<span id="L1460"><span class="lineNum">    1460</span>              :       size_type</span>
<span id="L1461"><span class="lineNum">    1461</span>              :       size() const noexcept</span>
<span id="L1462"><span class="lineNum">    1462</span>              :       { return _M_h.size(); }</span>
<span id="L1463"><span class="lineNum">    1463</span>              : </span>
<span id="L1464"><span class="lineNum">    1464</span>              :       ///  Returns the maximum size of the %unordered_multimap.</span>
<span id="L1465"><span class="lineNum">    1465</span>              :       size_type</span>
<span id="L1466"><span class="lineNum">    1466</span>              :       max_size() const noexcept</span>
<span id="L1467"><span class="lineNum">    1467</span>              :       { return _M_h.max_size(); }</span>
<span id="L1468"><span class="lineNum">    1468</span>              : </span>
<span id="L1469"><span class="lineNum">    1469</span>              :       // iterators.</span>
<span id="L1470"><span class="lineNum">    1470</span>              : </span>
<span id="L1471"><span class="lineNum">    1471</span>              :       /**</span>
<span id="L1472"><span class="lineNum">    1472</span>              :        *  Returns a read/write iterator that points to the first element in the</span>
<span id="L1473"><span class="lineNum">    1473</span>              :        *  %unordered_multimap.</span>
<span id="L1474"><span class="lineNum">    1474</span>              :        */</span>
<span id="L1475"><span class="lineNum">    1475</span>              :       iterator</span>
<span id="L1476"><span class="lineNum">    1476</span>              :       begin() noexcept</span>
<span id="L1477"><span class="lineNum">    1477</span>              :       { return _M_h.begin(); }</span>
<span id="L1478"><span class="lineNum">    1478</span>              : </span>
<span id="L1479"><span class="lineNum">    1479</span>              :       ///@{</span>
<span id="L1480"><span class="lineNum">    1480</span>              :       /**</span>
<span id="L1481"><span class="lineNum">    1481</span>              :        *  Returns a read-only (constant) iterator that points to the first</span>
<span id="L1482"><span class="lineNum">    1482</span>              :        *  element in the %unordered_multimap.</span>
<span id="L1483"><span class="lineNum">    1483</span>              :        */</span>
<span id="L1484"><span class="lineNum">    1484</span>              :       const_iterator</span>
<span id="L1485"><span class="lineNum">    1485</span>              :       begin() const noexcept</span>
<span id="L1486"><span class="lineNum">    1486</span>              :       { return _M_h.begin(); }</span>
<span id="L1487"><span class="lineNum">    1487</span>              : </span>
<span id="L1488"><span class="lineNum">    1488</span>              :       const_iterator</span>
<span id="L1489"><span class="lineNum">    1489</span>              :       cbegin() const noexcept</span>
<span id="L1490"><span class="lineNum">    1490</span>              :       { return _M_h.begin(); }</span>
<span id="L1491"><span class="lineNum">    1491</span>              :       ///@}</span>
<span id="L1492"><span class="lineNum">    1492</span>              : </span>
<span id="L1493"><span class="lineNum">    1493</span>              :       /**</span>
<span id="L1494"><span class="lineNum">    1494</span>              :        *  Returns a read/write iterator that points one past the last element in</span>
<span id="L1495"><span class="lineNum">    1495</span>              :        *  the %unordered_multimap.</span>
<span id="L1496"><span class="lineNum">    1496</span>              :        */</span>
<span id="L1497"><span class="lineNum">    1497</span>              :       iterator</span>
<span id="L1498"><span class="lineNum">    1498</span>              :       end() noexcept</span>
<span id="L1499"><span class="lineNum">    1499</span>              :       { return _M_h.end(); }</span>
<span id="L1500"><span class="lineNum">    1500</span>              : </span>
<span id="L1501"><span class="lineNum">    1501</span>              :       ///@{</span>
<span id="L1502"><span class="lineNum">    1502</span>              :       /**</span>
<span id="L1503"><span class="lineNum">    1503</span>              :        *  Returns a read-only (constant) iterator that points one past the last</span>
<span id="L1504"><span class="lineNum">    1504</span>              :        *  element in the %unordered_multimap.</span>
<span id="L1505"><span class="lineNum">    1505</span>              :        */</span>
<span id="L1506"><span class="lineNum">    1506</span>              :       const_iterator</span>
<span id="L1507"><span class="lineNum">    1507</span>              :       end() const noexcept</span>
<span id="L1508"><span class="lineNum">    1508</span>              :       { return _M_h.end(); }</span>
<span id="L1509"><span class="lineNum">    1509</span>              : </span>
<span id="L1510"><span class="lineNum">    1510</span>              :       const_iterator</span>
<span id="L1511"><span class="lineNum">    1511</span>              :       cend() const noexcept</span>
<span id="L1512"><span class="lineNum">    1512</span>              :       { return _M_h.end(); }</span>
<span id="L1513"><span class="lineNum">    1513</span>              :       ///@}</span>
<span id="L1514"><span class="lineNum">    1514</span>              : </span>
<span id="L1515"><span class="lineNum">    1515</span>              :       // modifiers.</span>
<span id="L1516"><span class="lineNum">    1516</span>              : </span>
<span id="L1517"><span class="lineNum">    1517</span>              :       /**</span>
<span id="L1518"><span class="lineNum">    1518</span>              :        *  @brief Attempts to build and insert a std::pair into the</span>
<span id="L1519"><span class="lineNum">    1519</span>              :        *  %unordered_multimap.</span>
<span id="L1520"><span class="lineNum">    1520</span>              :        *</span>
<span id="L1521"><span class="lineNum">    1521</span>              :        *  @param __args  Arguments used to generate a new pair instance (see</span>
<span id="L1522"><span class="lineNum">    1522</span>              :        *                std::piecewise_contruct for passing arguments to each</span>
<span id="L1523"><span class="lineNum">    1523</span>              :        *                part of the pair constructor).</span>
<span id="L1524"><span class="lineNum">    1524</span>              :        *</span>
<span id="L1525"><span class="lineNum">    1525</span>              :        *  @return  An iterator that points to the inserted pair.</span>
<span id="L1526"><span class="lineNum">    1526</span>              :        *</span>
<span id="L1527"><span class="lineNum">    1527</span>              :        *  This function attempts to build and insert a (key, value) %pair into</span>
<span id="L1528"><span class="lineNum">    1528</span>              :        *  the %unordered_multimap.</span>
<span id="L1529"><span class="lineNum">    1529</span>              :        *</span>
<span id="L1530"><span class="lineNum">    1530</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L1531"><span class="lineNum">    1531</span>              :        */</span>
<span id="L1532"><span class="lineNum">    1532</span>              :       template&lt;typename... _Args&gt;</span>
<span id="L1533"><span class="lineNum">    1533</span>              :         iterator</span>
<span id="L1534"><span class="lineNum">    1534</span>              :         emplace(_Args&amp;&amp;... __args)</span>
<span id="L1535"><span class="lineNum">    1535</span>              :         { return _M_h.emplace(std::forward&lt;_Args&gt;(__args)...); }</span>
<span id="L1536"><span class="lineNum">    1536</span>              : </span>
<span id="L1537"><span class="lineNum">    1537</span>              :       /**</span>
<span id="L1538"><span class="lineNum">    1538</span>              :        *  @brief Attempts to build and insert a std::pair into the</span>
<span id="L1539"><span class="lineNum">    1539</span>              :        *  %unordered_multimap.</span>
<span id="L1540"><span class="lineNum">    1540</span>              :        *</span>
<span id="L1541"><span class="lineNum">    1541</span>              :        *  @param  __pos  An iterator that serves as a hint as to where the pair</span>
<span id="L1542"><span class="lineNum">    1542</span>              :        *                should be inserted.</span>
<span id="L1543"><span class="lineNum">    1543</span>              :        *  @param  __args  Arguments used to generate a new pair instance (see</span>
<span id="L1544"><span class="lineNum">    1544</span>              :        *                 std::piecewise_contruct for passing arguments to each</span>
<span id="L1545"><span class="lineNum">    1545</span>              :        *                 part of the pair constructor).</span>
<span id="L1546"><span class="lineNum">    1546</span>              :        *  @return An iterator that points to the element with key of the</span>
<span id="L1547"><span class="lineNum">    1547</span>              :        *          std::pair built from @a __args.</span>
<span id="L1548"><span class="lineNum">    1548</span>              :        *</span>
<span id="L1549"><span class="lineNum">    1549</span>              :        *  Note that the first parameter is only a hint and can potentially</span>
<span id="L1550"><span class="lineNum">    1550</span>              :        *  improve the performance of the insertion process. A bad hint would</span>
<span id="L1551"><span class="lineNum">    1551</span>              :        *  cause no gains in efficiency.</span>
<span id="L1552"><span class="lineNum">    1552</span>              :        *</span>
<span id="L1553"><span class="lineNum">    1553</span>              :        *  See</span>
<span id="L1554"><span class="lineNum">    1554</span>              :        *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints</span>
<span id="L1555"><span class="lineNum">    1555</span>              :        *  for more on @a hinting.</span>
<span id="L1556"><span class="lineNum">    1556</span>              :        *</span>
<span id="L1557"><span class="lineNum">    1557</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L1558"><span class="lineNum">    1558</span>              :        */</span>
<span id="L1559"><span class="lineNum">    1559</span>              :       template&lt;typename... _Args&gt;</span>
<span id="L1560"><span class="lineNum">    1560</span>              :         iterator</span>
<span id="L1561"><span class="lineNum">    1561</span>              :         emplace_hint(const_iterator __pos, _Args&amp;&amp;... __args)</span>
<span id="L1562"><span class="lineNum">    1562</span>              :         { return _M_h.emplace_hint(__pos, std::forward&lt;_Args&gt;(__args)...); }</span>
<span id="L1563"><span class="lineNum">    1563</span>              : </span>
<span id="L1564"><span class="lineNum">    1564</span>              :       ///@{</span>
<span id="L1565"><span class="lineNum">    1565</span>              :       /**</span>
<span id="L1566"><span class="lineNum">    1566</span>              :        *  @brief Inserts a std::pair into the %unordered_multimap.</span>
<span id="L1567"><span class="lineNum">    1567</span>              :        *  @param __x Pair to be inserted (see std::make_pair for easy</span>
<span id="L1568"><span class="lineNum">    1568</span>              :        *             creation of pairs).</span>
<span id="L1569"><span class="lineNum">    1569</span>              :        *</span>
<span id="L1570"><span class="lineNum">    1570</span>              :        *  @return  An iterator that points to the inserted pair.</span>
<span id="L1571"><span class="lineNum">    1571</span>              :        *</span>
<span id="L1572"><span class="lineNum">    1572</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L1573"><span class="lineNum">    1573</span>              :        */</span>
<span id="L1574"><span class="lineNum">    1574</span>              :       iterator</span>
<span id="L1575"><span class="lineNum">    1575</span>              :       insert(const value_type&amp; __x)</span>
<span id="L1576"><span class="lineNum">    1576</span>              :       { return _M_h.insert(__x); }</span>
<span id="L1577"><span class="lineNum">    1577</span>              : </span>
<span id="L1578"><span class="lineNum">    1578</span>              :       iterator</span>
<span id="L1579"><span class="lineNum">    1579</span>              :       insert(value_type&amp;&amp; __x)</span>
<span id="L1580"><span class="lineNum">    1580</span>              :       { return _M_h.insert(std::move(__x)); }</span>
<span id="L1581"><span class="lineNum">    1581</span>              : </span>
<span id="L1582"><span class="lineNum">    1582</span>              :       template&lt;typename _Pair&gt;</span>
<span id="L1583"><span class="lineNum">    1583</span>              :         __enable_if_t&lt;is_constructible&lt;value_type, _Pair&amp;&amp;&gt;::value, iterator&gt;</span>
<span id="L1584"><span class="lineNum">    1584</span>              :         insert(_Pair&amp;&amp; __x)</span>
<span id="L1585"><span class="lineNum">    1585</span>              :         { return _M_h.emplace(std::forward&lt;_Pair&gt;(__x)); }</span>
<span id="L1586"><span class="lineNum">    1586</span>              :       ///@}</span>
<span id="L1587"><span class="lineNum">    1587</span>              : </span>
<span id="L1588"><span class="lineNum">    1588</span>              :       ///@{</span>
<span id="L1589"><span class="lineNum">    1589</span>              :       /**</span>
<span id="L1590"><span class="lineNum">    1590</span>              :        *  @brief Inserts a std::pair into the %unordered_multimap.</span>
<span id="L1591"><span class="lineNum">    1591</span>              :        *  @param  __hint  An iterator that serves as a hint as to where the</span>
<span id="L1592"><span class="lineNum">    1592</span>              :        *                 pair should be inserted.</span>
<span id="L1593"><span class="lineNum">    1593</span>              :        *  @param  __x  Pair to be inserted (see std::make_pair for easy creation</span>
<span id="L1594"><span class="lineNum">    1594</span>              :        *               of pairs).</span>
<span id="L1595"><span class="lineNum">    1595</span>              :        *  @return An iterator that points to the element with key of</span>
<span id="L1596"><span class="lineNum">    1596</span>              :        *           @a __x (may or may not be the %pair passed in).</span>
<span id="L1597"><span class="lineNum">    1597</span>              :        *</span>
<span id="L1598"><span class="lineNum">    1598</span>              :        *  Note that the first parameter is only a hint and can potentially</span>
<span id="L1599"><span class="lineNum">    1599</span>              :        *  improve the performance of the insertion process.  A bad hint would</span>
<span id="L1600"><span class="lineNum">    1600</span>              :        *  cause no gains in efficiency.</span>
<span id="L1601"><span class="lineNum">    1601</span>              :        *</span>
<span id="L1602"><span class="lineNum">    1602</span>              :        *  See</span>
<span id="L1603"><span class="lineNum">    1603</span>              :        *  https://gcc.gnu.org/onlinedocs/libstdc++/manual/associative.html#containers.associative.insert_hints</span>
<span id="L1604"><span class="lineNum">    1604</span>              :        *  for more on @a hinting.</span>
<span id="L1605"><span class="lineNum">    1605</span>              :        *</span>
<span id="L1606"><span class="lineNum">    1606</span>              :        *  Insertion requires amortized constant time.</span>
<span id="L1607"><span class="lineNum">    1607</span>              :        */</span>
<span id="L1608"><span class="lineNum">    1608</span>              :       iterator</span>
<span id="L1609"><span class="lineNum">    1609</span>              :       insert(const_iterator __hint, const value_type&amp; __x)</span>
<span id="L1610"><span class="lineNum">    1610</span>              :       { return _M_h.insert(__hint, __x); }</span>
<span id="L1611"><span class="lineNum">    1611</span>              : </span>
<span id="L1612"><span class="lineNum">    1612</span>              :       // _GLIBCXX_RESOLVE_LIB_DEFECTS</span>
<span id="L1613"><span class="lineNum">    1613</span>              :       // 2354. Unnecessary copying when inserting into maps with braced-init</span>
<span id="L1614"><span class="lineNum">    1614</span>              :       iterator</span>
<span id="L1615"><span class="lineNum">    1615</span>              :       insert(const_iterator __hint, value_type&amp;&amp; __x)</span>
<span id="L1616"><span class="lineNum">    1616</span>              :       { return _M_h.insert(__hint, std::move(__x)); }</span>
<span id="L1617"><span class="lineNum">    1617</span>              : </span>
<span id="L1618"><span class="lineNum">    1618</span>              :       template&lt;typename _Pair&gt;</span>
<span id="L1619"><span class="lineNum">    1619</span>              :         __enable_if_t&lt;is_constructible&lt;value_type, _Pair&amp;&amp;&gt;::value, iterator&gt;</span>
<span id="L1620"><span class="lineNum">    1620</span>              :         insert(const_iterator __hint, _Pair&amp;&amp; __x)</span>
<span id="L1621"><span class="lineNum">    1621</span>              :         { return _M_h.emplace_hint(__hint, std::forward&lt;_Pair&gt;(__x)); }</span>
<span id="L1622"><span class="lineNum">    1622</span>              :       ///@}</span>
<span id="L1623"><span class="lineNum">    1623</span>              : </span>
<span id="L1624"><span class="lineNum">    1624</span>              :       /**</span>
<span id="L1625"><span class="lineNum">    1625</span>              :        *  @brief A template function that attempts to insert a range of</span>
<span id="L1626"><span class="lineNum">    1626</span>              :        *  elements.</span>
<span id="L1627"><span class="lineNum">    1627</span>              :        *  @param  __first  Iterator pointing to the start of the range to be</span>
<span id="L1628"><span class="lineNum">    1628</span>              :        *                   inserted.</span>
<span id="L1629"><span class="lineNum">    1629</span>              :        *  @param  __last  Iterator pointing to the end of the range.</span>
<span id="L1630"><span class="lineNum">    1630</span>              :        *</span>
<span id="L1631"><span class="lineNum">    1631</span>              :        *  Complexity similar to that of the range constructor.</span>
<span id="L1632"><span class="lineNum">    1632</span>              :        */</span>
<span id="L1633"><span class="lineNum">    1633</span>              :       template&lt;typename _InputIterator&gt;</span>
<span id="L1634"><span class="lineNum">    1634</span>              :         void</span>
<span id="L1635"><span class="lineNum">    1635</span>              :         insert(_InputIterator __first, _InputIterator __last)</span>
<span id="L1636"><span class="lineNum">    1636</span>              :         { _M_h.insert(__first, __last); }</span>
<span id="L1637"><span class="lineNum">    1637</span>              : </span>
<span id="L1638"><span class="lineNum">    1638</span>              :       /**</span>
<span id="L1639"><span class="lineNum">    1639</span>              :        *  @brief Attempts to insert a list of elements into the</span>
<span id="L1640"><span class="lineNum">    1640</span>              :        *  %unordered_multimap.</span>
<span id="L1641"><span class="lineNum">    1641</span>              :        *  @param  __l  A std::initializer_list&lt;value_type&gt; of elements</span>
<span id="L1642"><span class="lineNum">    1642</span>              :        *               to be inserted.</span>
<span id="L1643"><span class="lineNum">    1643</span>              :        *</span>
<span id="L1644"><span class="lineNum">    1644</span>              :        *  Complexity similar to that of the range constructor.</span>
<span id="L1645"><span class="lineNum">    1645</span>              :        */</span>
<span id="L1646"><span class="lineNum">    1646</span>              :       void</span>
<span id="L1647"><span class="lineNum">    1647</span>              :       insert(initializer_list&lt;value_type&gt; __l)</span>
<span id="L1648"><span class="lineNum">    1648</span>              :       { _M_h.insert(__l); }</span>
<span id="L1649"><span class="lineNum">    1649</span>              : </span>
<span id="L1650"><span class="lineNum">    1650</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L1651"><span class="lineNum">    1651</span>              :       /// Extract a node.</span>
<span id="L1652"><span class="lineNum">    1652</span>              :       node_type</span>
<span id="L1653"><span class="lineNum">    1653</span>              :       extract(const_iterator __pos)</span>
<span id="L1654"><span class="lineNum">    1654</span>              :       {</span>
<span id="L1655"><span class="lineNum">    1655</span>              :         __glibcxx_assert(__pos != end());</span>
<span id="L1656"><span class="lineNum">    1656</span>              :         return _M_h.extract(__pos);</span>
<span id="L1657"><span class="lineNum">    1657</span>              :       }</span>
<span id="L1658"><span class="lineNum">    1658</span>              : </span>
<span id="L1659"><span class="lineNum">    1659</span>              :       /// Extract a node.</span>
<span id="L1660"><span class="lineNum">    1660</span>              :       node_type</span>
<span id="L1661"><span class="lineNum">    1661</span>              :       extract(const key_type&amp; __key)</span>
<span id="L1662"><span class="lineNum">    1662</span>              :       { return _M_h.extract(__key); }</span>
<span id="L1663"><span class="lineNum">    1663</span>              : </span>
<span id="L1664"><span class="lineNum">    1664</span>              :       /// Re-insert an extracted node.</span>
<span id="L1665"><span class="lineNum">    1665</span>              :       iterator</span>
<span id="L1666"><span class="lineNum">    1666</span>              :       insert(node_type&amp;&amp; __nh)</span>
<span id="L1667"><span class="lineNum">    1667</span>              :       { return _M_h._M_reinsert_node_multi(cend(), std::move(__nh)); }</span>
<span id="L1668"><span class="lineNum">    1668</span>              : </span>
<span id="L1669"><span class="lineNum">    1669</span>              :       /// Re-insert an extracted node.</span>
<span id="L1670"><span class="lineNum">    1670</span>              :       iterator</span>
<span id="L1671"><span class="lineNum">    1671</span>              :       insert(const_iterator __hint, node_type&amp;&amp; __nh)</span>
<span id="L1672"><span class="lineNum">    1672</span>              :       { return _M_h._M_reinsert_node_multi(__hint, std::move(__nh)); }</span>
<span id="L1673"><span class="lineNum">    1673</span>              : #endif // C++17</span>
<span id="L1674"><span class="lineNum">    1674</span>              : </span>
<span id="L1675"><span class="lineNum">    1675</span>              :       ///@{</span>
<span id="L1676"><span class="lineNum">    1676</span>              :       /**</span>
<span id="L1677"><span class="lineNum">    1677</span>              :        *  @brief Erases an element from an %unordered_multimap.</span>
<span id="L1678"><span class="lineNum">    1678</span>              :        *  @param  __position  An iterator pointing to the element to be erased.</span>
<span id="L1679"><span class="lineNum">    1679</span>              :        *  @return An iterator pointing to the element immediately following</span>
<span id="L1680"><span class="lineNum">    1680</span>              :        *          @a __position prior to the element being erased. If no such</span>
<span id="L1681"><span class="lineNum">    1681</span>              :        *          element exists, end() is returned.</span>
<span id="L1682"><span class="lineNum">    1682</span>              :        *</span>
<span id="L1683"><span class="lineNum">    1683</span>              :        *  This function erases an element, pointed to by the given iterator,</span>
<span id="L1684"><span class="lineNum">    1684</span>              :        *  from an %unordered_multimap.</span>
<span id="L1685"><span class="lineNum">    1685</span>              :        *  Note that this function only erases the element, and that if the</span>
<span id="L1686"><span class="lineNum">    1686</span>              :        *  element is itself a pointer, the pointed-to memory is not touched in</span>
<span id="L1687"><span class="lineNum">    1687</span>              :        *  any way.  Managing the pointer is the user's responsibility.</span>
<span id="L1688"><span class="lineNum">    1688</span>              :        */</span>
<span id="L1689"><span class="lineNum">    1689</span>              :       iterator</span>
<span id="L1690"><span class="lineNum">    1690</span>              :       erase(const_iterator __position)</span>
<span id="L1691"><span class="lineNum">    1691</span>              :       { return _M_h.erase(__position); }</span>
<span id="L1692"><span class="lineNum">    1692</span>              : </span>
<span id="L1693"><span class="lineNum">    1693</span>              :       // LWG 2059.</span>
<span id="L1694"><span class="lineNum">    1694</span>              :       iterator</span>
<span id="L1695"><span class="lineNum">    1695</span>              :       erase(iterator __position)</span>
<span id="L1696"><span class="lineNum">    1696</span>              :       { return _M_h.erase(__position); }</span>
<span id="L1697"><span class="lineNum">    1697</span>              :       ///@}</span>
<span id="L1698"><span class="lineNum">    1698</span>              : </span>
<span id="L1699"><span class="lineNum">    1699</span>              :       /**</span>
<span id="L1700"><span class="lineNum">    1700</span>              :        *  @brief Erases elements according to the provided key.</span>
<span id="L1701"><span class="lineNum">    1701</span>              :        *  @param  __x  Key of elements to be erased.</span>
<span id="L1702"><span class="lineNum">    1702</span>              :        *  @return  The number of elements erased.</span>
<span id="L1703"><span class="lineNum">    1703</span>              :        *</span>
<span id="L1704"><span class="lineNum">    1704</span>              :        *  This function erases all the elements located by the given key from</span>
<span id="L1705"><span class="lineNum">    1705</span>              :        *  an %unordered_multimap.</span>
<span id="L1706"><span class="lineNum">    1706</span>              :        *  Note that this function only erases the element, and that if the</span>
<span id="L1707"><span class="lineNum">    1707</span>              :        *  element is itself a pointer, the pointed-to memory is not touched in</span>
<span id="L1708"><span class="lineNum">    1708</span>              :        *  any way.  Managing the pointer is the user's responsibility.</span>
<span id="L1709"><span class="lineNum">    1709</span>              :        */</span>
<span id="L1710"><span class="lineNum">    1710</span>              :       size_type</span>
<span id="L1711"><span class="lineNum">    1711</span>              :       erase(const key_type&amp; __x)</span>
<span id="L1712"><span class="lineNum">    1712</span>              :       { return _M_h.erase(__x); }</span>
<span id="L1713"><span class="lineNum">    1713</span>              : </span>
<span id="L1714"><span class="lineNum">    1714</span>              :       /**</span>
<span id="L1715"><span class="lineNum">    1715</span>              :        *  @brief Erases a [__first,__last) range of elements from an</span>
<span id="L1716"><span class="lineNum">    1716</span>              :        *  %unordered_multimap.</span>
<span id="L1717"><span class="lineNum">    1717</span>              :        *  @param  __first  Iterator pointing to the start of the range to be</span>
<span id="L1718"><span class="lineNum">    1718</span>              :        *                  erased.</span>
<span id="L1719"><span class="lineNum">    1719</span>              :        *  @param __last  Iterator pointing to the end of the range to</span>
<span id="L1720"><span class="lineNum">    1720</span>              :        *                be erased.</span>
<span id="L1721"><span class="lineNum">    1721</span>              :        *  @return The iterator @a __last.</span>
<span id="L1722"><span class="lineNum">    1722</span>              :        *</span>
<span id="L1723"><span class="lineNum">    1723</span>              :        *  This function erases a sequence of elements from an</span>
<span id="L1724"><span class="lineNum">    1724</span>              :        *  %unordered_multimap.</span>
<span id="L1725"><span class="lineNum">    1725</span>              :        *  Note that this function only erases the elements, and that if</span>
<span id="L1726"><span class="lineNum">    1726</span>              :        *  the element is itself a pointer, the pointed-to memory is not touched</span>
<span id="L1727"><span class="lineNum">    1727</span>              :        *  in any way.  Managing the pointer is the user's responsibility.</span>
<span id="L1728"><span class="lineNum">    1728</span>              :        */</span>
<span id="L1729"><span class="lineNum">    1729</span>              :       iterator</span>
<span id="L1730"><span class="lineNum">    1730</span>              :       erase(const_iterator __first, const_iterator __last)</span>
<span id="L1731"><span class="lineNum">    1731</span>              :       { return _M_h.erase(__first, __last); }</span>
<span id="L1732"><span class="lineNum">    1732</span>              : </span>
<span id="L1733"><span class="lineNum">    1733</span>              :       /**</span>
<span id="L1734"><span class="lineNum">    1734</span>              :        *  Erases all elements in an %unordered_multimap.</span>
<span id="L1735"><span class="lineNum">    1735</span>              :        *  Note that this function only erases the elements, and that if the</span>
<span id="L1736"><span class="lineNum">    1736</span>              :        *  elements themselves are pointers, the pointed-to memory is not touched</span>
<span id="L1737"><span class="lineNum">    1737</span>              :        *  in any way.  Managing the pointer is the user's responsibility.</span>
<span id="L1738"><span class="lineNum">    1738</span>              :        */</span>
<span id="L1739"><span class="lineNum">    1739</span>              :       void</span>
<span id="L1740"><span class="lineNum">    1740</span>              :       clear() noexcept</span>
<span id="L1741"><span class="lineNum">    1741</span>              :       { _M_h.clear(); }</span>
<span id="L1742"><span class="lineNum">    1742</span>              : </span>
<span id="L1743"><span class="lineNum">    1743</span>              :       /**</span>
<span id="L1744"><span class="lineNum">    1744</span>              :        *  @brief  Swaps data with another %unordered_multimap.</span>
<span id="L1745"><span class="lineNum">    1745</span>              :        *  @param  __x  An %unordered_multimap of the same element and allocator</span>
<span id="L1746"><span class="lineNum">    1746</span>              :        *  types.</span>
<span id="L1747"><span class="lineNum">    1747</span>              :        *</span>
<span id="L1748"><span class="lineNum">    1748</span>              :        *  This exchanges the elements between two %unordered_multimap in</span>
<span id="L1749"><span class="lineNum">    1749</span>              :        *  constant time.</span>
<span id="L1750"><span class="lineNum">    1750</span>              :        *  Note that the global std::swap() function is specialized such that</span>
<span id="L1751"><span class="lineNum">    1751</span>              :        *  std::swap(m1,m2) will feed to this function.</span>
<span id="L1752"><span class="lineNum">    1752</span>              :        */</span>
<span id="L1753"><span class="lineNum">    1753</span>              :       void</span>
<span id="L1754"><span class="lineNum">    1754</span>              :       swap(unordered_multimap&amp; __x)</span>
<span id="L1755"><span class="lineNum">    1755</span>              :       noexcept( noexcept(_M_h.swap(__x._M_h)) )</span>
<span id="L1756"><span class="lineNum">    1756</span>              :       { _M_h.swap(__x._M_h); }</span>
<span id="L1757"><span class="lineNum">    1757</span>              : </span>
<span id="L1758"><span class="lineNum">    1758</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L1759"><span class="lineNum">    1759</span>              :       template&lt;typename, typename, typename&gt;</span>
<span id="L1760"><span class="lineNum">    1760</span>              :         friend class std::_Hash_merge_helper;</span>
<span id="L1761"><span class="lineNum">    1761</span>              : </span>
<span id="L1762"><span class="lineNum">    1762</span>              :       template&lt;typename _H2, typename _P2&gt;</span>
<span id="L1763"><span class="lineNum">    1763</span>              :         void</span>
<span id="L1764"><span class="lineNum">    1764</span>              :         merge(unordered_multimap&lt;_Key, _Tp, _H2, _P2, _Alloc&gt;&amp; __source)</span>
<span id="L1765"><span class="lineNum">    1765</span>              :         {</span>
<span id="L1766"><span class="lineNum">    1766</span>              :           using _Merge_helper</span>
<span id="L1767"><span class="lineNum">    1767</span>              :             = _Hash_merge_helper&lt;unordered_multimap, _H2, _P2&gt;;</span>
<span id="L1768"><span class="lineNum">    1768</span>              :           _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));</span>
<span id="L1769"><span class="lineNum">    1769</span>              :         }</span>
<span id="L1770"><span class="lineNum">    1770</span>              : </span>
<span id="L1771"><span class="lineNum">    1771</span>              :       template&lt;typename _H2, typename _P2&gt;</span>
<span id="L1772"><span class="lineNum">    1772</span>              :         void</span>
<span id="L1773"><span class="lineNum">    1773</span>              :         merge(unordered_multimap&lt;_Key, _Tp, _H2, _P2, _Alloc&gt;&amp;&amp; __source)</span>
<span id="L1774"><span class="lineNum">    1774</span>              :         { merge(__source); }</span>
<span id="L1775"><span class="lineNum">    1775</span>              : </span>
<span id="L1776"><span class="lineNum">    1776</span>              :       template&lt;typename _H2, typename _P2&gt;</span>
<span id="L1777"><span class="lineNum">    1777</span>              :         void</span>
<span id="L1778"><span class="lineNum">    1778</span>              :         merge(unordered_map&lt;_Key, _Tp, _H2, _P2, _Alloc&gt;&amp; __source)</span>
<span id="L1779"><span class="lineNum">    1779</span>              :         {</span>
<span id="L1780"><span class="lineNum">    1780</span>              :           using _Merge_helper</span>
<span id="L1781"><span class="lineNum">    1781</span>              :             = _Hash_merge_helper&lt;unordered_multimap, _H2, _P2&gt;;</span>
<span id="L1782"><span class="lineNum">    1782</span>              :           _M_h._M_merge_multi(_Merge_helper::_S_get_table(__source));</span>
<span id="L1783"><span class="lineNum">    1783</span>              :         }</span>
<span id="L1784"><span class="lineNum">    1784</span>              : </span>
<span id="L1785"><span class="lineNum">    1785</span>              :       template&lt;typename _H2, typename _P2&gt;</span>
<span id="L1786"><span class="lineNum">    1786</span>              :         void</span>
<span id="L1787"><span class="lineNum">    1787</span>              :         merge(unordered_map&lt;_Key, _Tp, _H2, _P2, _Alloc&gt;&amp;&amp; __source)</span>
<span id="L1788"><span class="lineNum">    1788</span>              :         { merge(__source); }</span>
<span id="L1789"><span class="lineNum">    1789</span>              : #endif // C++17</span>
<span id="L1790"><span class="lineNum">    1790</span>              : </span>
<span id="L1791"><span class="lineNum">    1791</span>              :       // observers.</span>
<span id="L1792"><span class="lineNum">    1792</span>              : </span>
<span id="L1793"><span class="lineNum">    1793</span>              :       ///  Returns the hash functor object with which the %unordered_multimap</span>
<span id="L1794"><span class="lineNum">    1794</span>              :       ///  was constructed.</span>
<span id="L1795"><span class="lineNum">    1795</span>              :       hasher</span>
<span id="L1796"><span class="lineNum">    1796</span>              :       hash_function() const</span>
<span id="L1797"><span class="lineNum">    1797</span>              :       { return _M_h.hash_function(); }</span>
<span id="L1798"><span class="lineNum">    1798</span>              : </span>
<span id="L1799"><span class="lineNum">    1799</span>              :       ///  Returns the key comparison object with which the %unordered_multimap</span>
<span id="L1800"><span class="lineNum">    1800</span>              :       ///  was constructed.</span>
<span id="L1801"><span class="lineNum">    1801</span>              :       key_equal</span>
<span id="L1802"><span class="lineNum">    1802</span>              :       key_eq() const</span>
<span id="L1803"><span class="lineNum">    1803</span>              :       { return _M_h.key_eq(); }</span>
<span id="L1804"><span class="lineNum">    1804</span>              : </span>
<span id="L1805"><span class="lineNum">    1805</span>              :       // lookup.</span>
<span id="L1806"><span class="lineNum">    1806</span>              : </span>
<span id="L1807"><span class="lineNum">    1807</span>              :       ///@{</span>
<span id="L1808"><span class="lineNum">    1808</span>              :       /**</span>
<span id="L1809"><span class="lineNum">    1809</span>              :        *  @brief Tries to locate an element in an %unordered_multimap.</span>
<span id="L1810"><span class="lineNum">    1810</span>              :        *  @param  __x  Key to be located.</span>
<span id="L1811"><span class="lineNum">    1811</span>              :        *  @return  Iterator pointing to sought-after element, or end() if not</span>
<span id="L1812"><span class="lineNum">    1812</span>              :        *           found.</span>
<span id="L1813"><span class="lineNum">    1813</span>              :        *</span>
<span id="L1814"><span class="lineNum">    1814</span>              :        *  This function takes a key and tries to locate the element with which</span>
<span id="L1815"><span class="lineNum">    1815</span>              :        *  the key matches.  If successful the function returns an iterator</span>
<span id="L1816"><span class="lineNum">    1816</span>              :        *  pointing to the sought after element.  If unsuccessful it returns the</span>
<span id="L1817"><span class="lineNum">    1817</span>              :        *  past-the-end ( @c end() ) iterator.</span>
<span id="L1818"><span class="lineNum">    1818</span>              :        */</span>
<span id="L1819"><span class="lineNum">    1819</span>              :       iterator</span>
<span id="L1820"><span class="lineNum">    1820</span>              :       find(const key_type&amp; __x)</span>
<span id="L1821"><span class="lineNum">    1821</span>              :       { return _M_h.find(__x); }</span>
<span id="L1822"><span class="lineNum">    1822</span>              : </span>
<span id="L1823"><span class="lineNum">    1823</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L1824"><span class="lineNum">    1824</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L1825"><span class="lineNum">    1825</span>              :         auto</span>
<span id="L1826"><span class="lineNum">    1826</span>              :         find(const _Kt&amp; __x) -&gt; decltype(_M_h._M_find_tr(__x))</span>
<span id="L1827"><span class="lineNum">    1827</span>              :         { return _M_h._M_find_tr(__x); }</span>
<span id="L1828"><span class="lineNum">    1828</span>              : #endif</span>
<span id="L1829"><span class="lineNum">    1829</span>              : </span>
<span id="L1830"><span class="lineNum">    1830</span>              :       const_iterator</span>
<span id="L1831"><span class="lineNum">    1831</span>              :       find(const key_type&amp; __x) const</span>
<span id="L1832"><span class="lineNum">    1832</span>              :       { return _M_h.find(__x); }</span>
<span id="L1833"><span class="lineNum">    1833</span>              : </span>
<span id="L1834"><span class="lineNum">    1834</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L1835"><span class="lineNum">    1835</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L1836"><span class="lineNum">    1836</span>              :         auto</span>
<span id="L1837"><span class="lineNum">    1837</span>              :         find(const _Kt&amp; __x) const -&gt; decltype(_M_h._M_find_tr(__x))</span>
<span id="L1838"><span class="lineNum">    1838</span>              :         { return _M_h._M_find_tr(__x); }</span>
<span id="L1839"><span class="lineNum">    1839</span>              : #endif</span>
<span id="L1840"><span class="lineNum">    1840</span>              :       ///@}</span>
<span id="L1841"><span class="lineNum">    1841</span>              : </span>
<span id="L1842"><span class="lineNum">    1842</span>              :       ///@{</span>
<span id="L1843"><span class="lineNum">    1843</span>              :       /**</span>
<span id="L1844"><span class="lineNum">    1844</span>              :        *  @brief  Finds the number of elements.</span>
<span id="L1845"><span class="lineNum">    1845</span>              :        *  @param  __x  Key to count.</span>
<span id="L1846"><span class="lineNum">    1846</span>              :        *  @return  Number of elements with specified key.</span>
<span id="L1847"><span class="lineNum">    1847</span>              :        */</span>
<span id="L1848"><span class="lineNum">    1848</span>              :       size_type</span>
<span id="L1849"><span class="lineNum">    1849</span>              :       count(const key_type&amp; __x) const</span>
<span id="L1850"><span class="lineNum">    1850</span>              :       { return _M_h.count(__x); }</span>
<span id="L1851"><span class="lineNum">    1851</span>              : </span>
<span id="L1852"><span class="lineNum">    1852</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L1853"><span class="lineNum">    1853</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L1854"><span class="lineNum">    1854</span>              :         auto</span>
<span id="L1855"><span class="lineNum">    1855</span>              :         count(const _Kt&amp; __x) const -&gt; decltype(_M_h._M_count_tr(__x))</span>
<span id="L1856"><span class="lineNum">    1856</span>              :         { return _M_h._M_count_tr(__x); }</span>
<span id="L1857"><span class="lineNum">    1857</span>              : #endif</span>
<span id="L1858"><span class="lineNum">    1858</span>              :       ///@}</span>
<span id="L1859"><span class="lineNum">    1859</span>              : </span>
<span id="L1860"><span class="lineNum">    1860</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L1861"><span class="lineNum">    1861</span>              :       ///@{</span>
<span id="L1862"><span class="lineNum">    1862</span>              :       /**</span>
<span id="L1863"><span class="lineNum">    1863</span>              :        *  @brief  Finds whether an element with the given key exists.</span>
<span id="L1864"><span class="lineNum">    1864</span>              :        *  @param  __x  Key of elements to be located.</span>
<span id="L1865"><span class="lineNum">    1865</span>              :        *  @return  True if there is any element with the specified key.</span>
<span id="L1866"><span class="lineNum">    1866</span>              :        */</span>
<span id="L1867"><span class="lineNum">    1867</span>              :       bool</span>
<span id="L1868"><span class="lineNum">    1868</span>              :       contains(const key_type&amp; __x) const</span>
<span id="L1869"><span class="lineNum">    1869</span>              :       { return _M_h.find(__x) != _M_h.end(); }</span>
<span id="L1870"><span class="lineNum">    1870</span>              : </span>
<span id="L1871"><span class="lineNum">    1871</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L1872"><span class="lineNum">    1872</span>              :         auto</span>
<span id="L1873"><span class="lineNum">    1873</span>              :         contains(const _Kt&amp; __x) const</span>
<span id="L1874"><span class="lineNum">    1874</span>              :         -&gt; decltype(_M_h._M_find_tr(__x), void(), true)</span>
<span id="L1875"><span class="lineNum">    1875</span>              :         { return _M_h._M_find_tr(__x) != _M_h.end(); }</span>
<span id="L1876"><span class="lineNum">    1876</span>              :       ///@}</span>
<span id="L1877"><span class="lineNum">    1877</span>              : #endif</span>
<span id="L1878"><span class="lineNum">    1878</span>              : </span>
<span id="L1879"><span class="lineNum">    1879</span>              :       ///@{</span>
<span id="L1880"><span class="lineNum">    1880</span>              :       /**</span>
<span id="L1881"><span class="lineNum">    1881</span>              :        *  @brief Finds a subsequence matching given key.</span>
<span id="L1882"><span class="lineNum">    1882</span>              :        *  @param  __x  Key to be located.</span>
<span id="L1883"><span class="lineNum">    1883</span>              :        *  @return  Pair of iterators that possibly points to the subsequence</span>
<span id="L1884"><span class="lineNum">    1884</span>              :        *           matching given key.</span>
<span id="L1885"><span class="lineNum">    1885</span>              :        */</span>
<span id="L1886"><span class="lineNum">    1886</span>              :       std::pair&lt;iterator, iterator&gt;</span>
<span id="L1887"><span class="lineNum">    1887</span>              :       equal_range(const key_type&amp; __x)</span>
<span id="L1888"><span class="lineNum">    1888</span>              :       { return _M_h.equal_range(__x); }</span>
<span id="L1889"><span class="lineNum">    1889</span>              : </span>
<span id="L1890"><span class="lineNum">    1890</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L1891"><span class="lineNum">    1891</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L1892"><span class="lineNum">    1892</span>              :         auto</span>
<span id="L1893"><span class="lineNum">    1893</span>              :         equal_range(const _Kt&amp; __x)</span>
<span id="L1894"><span class="lineNum">    1894</span>              :         -&gt; decltype(_M_h._M_equal_range_tr(__x))</span>
<span id="L1895"><span class="lineNum">    1895</span>              :         { return _M_h._M_equal_range_tr(__x); }</span>
<span id="L1896"><span class="lineNum">    1896</span>              : #endif</span>
<span id="L1897"><span class="lineNum">    1897</span>              : </span>
<span id="L1898"><span class="lineNum">    1898</span>              :       std::pair&lt;const_iterator, const_iterator&gt;</span>
<span id="L1899"><span class="lineNum">    1899</span>              :       equal_range(const key_type&amp; __x) const</span>
<span id="L1900"><span class="lineNum">    1900</span>              :       { return _M_h.equal_range(__x); }</span>
<span id="L1901"><span class="lineNum">    1901</span>              : </span>
<span id="L1902"><span class="lineNum">    1902</span>              : #if __cplusplus &gt; 201703L</span>
<span id="L1903"><span class="lineNum">    1903</span>              :       template&lt;typename _Kt&gt;</span>
<span id="L1904"><span class="lineNum">    1904</span>              :         auto</span>
<span id="L1905"><span class="lineNum">    1905</span>              :         equal_range(const _Kt&amp; __x) const</span>
<span id="L1906"><span class="lineNum">    1906</span>              :         -&gt; decltype(_M_h._M_equal_range_tr(__x))</span>
<span id="L1907"><span class="lineNum">    1907</span>              :         { return _M_h._M_equal_range_tr(__x); }</span>
<span id="L1908"><span class="lineNum">    1908</span>              : #endif</span>
<span id="L1909"><span class="lineNum">    1909</span>              :       ///@}</span>
<span id="L1910"><span class="lineNum">    1910</span>              : </span>
<span id="L1911"><span class="lineNum">    1911</span>              :       // bucket interface.</span>
<span id="L1912"><span class="lineNum">    1912</span>              : </span>
<span id="L1913"><span class="lineNum">    1913</span>              :       /// Returns the number of buckets of the %unordered_multimap.</span>
<span id="L1914"><span class="lineNum">    1914</span>              :       size_type</span>
<span id="L1915"><span class="lineNum">    1915</span>              :       bucket_count() const noexcept</span>
<span id="L1916"><span class="lineNum">    1916</span>              :       { return _M_h.bucket_count(); }</span>
<span id="L1917"><span class="lineNum">    1917</span>              : </span>
<span id="L1918"><span class="lineNum">    1918</span>              :       /// Returns the maximum number of buckets of the %unordered_multimap.</span>
<span id="L1919"><span class="lineNum">    1919</span>              :       size_type</span>
<span id="L1920"><span class="lineNum">    1920</span>              :       max_bucket_count() const noexcept</span>
<span id="L1921"><span class="lineNum">    1921</span>              :       { return _M_h.max_bucket_count(); }</span>
<span id="L1922"><span class="lineNum">    1922</span>              : </span>
<span id="L1923"><span class="lineNum">    1923</span>              :       /*</span>
<span id="L1924"><span class="lineNum">    1924</span>              :        * @brief  Returns the number of elements in a given bucket.</span>
<span id="L1925"><span class="lineNum">    1925</span>              :        * @param  __n  A bucket index.</span>
<span id="L1926"><span class="lineNum">    1926</span>              :        * @return  The number of elements in the bucket.</span>
<span id="L1927"><span class="lineNum">    1927</span>              :        */</span>
<span id="L1928"><span class="lineNum">    1928</span>              :       size_type</span>
<span id="L1929"><span class="lineNum">    1929</span>              :       bucket_size(size_type __n) const</span>
<span id="L1930"><span class="lineNum">    1930</span>              :       { return _M_h.bucket_size(__n); }</span>
<span id="L1931"><span class="lineNum">    1931</span>              : </span>
<span id="L1932"><span class="lineNum">    1932</span>              :       /*</span>
<span id="L1933"><span class="lineNum">    1933</span>              :        * @brief  Returns the bucket index of a given element.</span>
<span id="L1934"><span class="lineNum">    1934</span>              :        * @param  __key  A key instance.</span>
<span id="L1935"><span class="lineNum">    1935</span>              :        * @return  The key bucket index.</span>
<span id="L1936"><span class="lineNum">    1936</span>              :        */</span>
<span id="L1937"><span class="lineNum">    1937</span>              :       size_type</span>
<span id="L1938"><span class="lineNum">    1938</span>              :       bucket(const key_type&amp; __key) const</span>
<span id="L1939"><span class="lineNum">    1939</span>              :       { return _M_h.bucket(__key); }</span>
<span id="L1940"><span class="lineNum">    1940</span>              :       </span>
<span id="L1941"><span class="lineNum">    1941</span>              :       /**</span>
<span id="L1942"><span class="lineNum">    1942</span>              :        *  @brief  Returns a read/write iterator pointing to the first bucket</span>
<span id="L1943"><span class="lineNum">    1943</span>              :        *         element.</span>
<span id="L1944"><span class="lineNum">    1944</span>              :        *  @param  __n The bucket index.</span>
<span id="L1945"><span class="lineNum">    1945</span>              :        *  @return  A read/write local iterator.</span>
<span id="L1946"><span class="lineNum">    1946</span>              :        */</span>
<span id="L1947"><span class="lineNum">    1947</span>              :       local_iterator</span>
<span id="L1948"><span class="lineNum">    1948</span>              :       begin(size_type __n)</span>
<span id="L1949"><span class="lineNum">    1949</span>              :       { return _M_h.begin(__n); }</span>
<span id="L1950"><span class="lineNum">    1950</span>              : </span>
<span id="L1951"><span class="lineNum">    1951</span>              :       ///@{</span>
<span id="L1952"><span class="lineNum">    1952</span>              :       /**</span>
<span id="L1953"><span class="lineNum">    1953</span>              :        *  @brief  Returns a read-only (constant) iterator pointing to the first</span>
<span id="L1954"><span class="lineNum">    1954</span>              :        *         bucket element.</span>
<span id="L1955"><span class="lineNum">    1955</span>              :        *  @param  __n The bucket index.</span>
<span id="L1956"><span class="lineNum">    1956</span>              :        *  @return  A read-only local iterator.</span>
<span id="L1957"><span class="lineNum">    1957</span>              :        */</span>
<span id="L1958"><span class="lineNum">    1958</span>              :       const_local_iterator</span>
<span id="L1959"><span class="lineNum">    1959</span>              :       begin(size_type __n) const</span>
<span id="L1960"><span class="lineNum">    1960</span>              :       { return _M_h.begin(__n); }</span>
<span id="L1961"><span class="lineNum">    1961</span>              : </span>
<span id="L1962"><span class="lineNum">    1962</span>              :       const_local_iterator</span>
<span id="L1963"><span class="lineNum">    1963</span>              :       cbegin(size_type __n) const</span>
<span id="L1964"><span class="lineNum">    1964</span>              :       { return _M_h.cbegin(__n); }</span>
<span id="L1965"><span class="lineNum">    1965</span>              :       ///@}</span>
<span id="L1966"><span class="lineNum">    1966</span>              : </span>
<span id="L1967"><span class="lineNum">    1967</span>              :       /**</span>
<span id="L1968"><span class="lineNum">    1968</span>              :        *  @brief  Returns a read/write iterator pointing to one past the last</span>
<span id="L1969"><span class="lineNum">    1969</span>              :        *         bucket elements.</span>
<span id="L1970"><span class="lineNum">    1970</span>              :        *  @param  __n The bucket index.</span>
<span id="L1971"><span class="lineNum">    1971</span>              :        *  @return  A read/write local iterator.</span>
<span id="L1972"><span class="lineNum">    1972</span>              :        */</span>
<span id="L1973"><span class="lineNum">    1973</span>              :       local_iterator</span>
<span id="L1974"><span class="lineNum">    1974</span>              :       end(size_type __n)</span>
<span id="L1975"><span class="lineNum">    1975</span>              :       { return _M_h.end(__n); }</span>
<span id="L1976"><span class="lineNum">    1976</span>              : </span>
<span id="L1977"><span class="lineNum">    1977</span>              :       ///@{</span>
<span id="L1978"><span class="lineNum">    1978</span>              :       /**</span>
<span id="L1979"><span class="lineNum">    1979</span>              :        *  @brief  Returns a read-only (constant) iterator pointing to one past</span>
<span id="L1980"><span class="lineNum">    1980</span>              :        *         the last bucket elements.</span>
<span id="L1981"><span class="lineNum">    1981</span>              :        *  @param  __n The bucket index.</span>
<span id="L1982"><span class="lineNum">    1982</span>              :        *  @return  A read-only local iterator.</span>
<span id="L1983"><span class="lineNum">    1983</span>              :        */</span>
<span id="L1984"><span class="lineNum">    1984</span>              :       const_local_iterator</span>
<span id="L1985"><span class="lineNum">    1985</span>              :       end(size_type __n) const</span>
<span id="L1986"><span class="lineNum">    1986</span>              :       { return _M_h.end(__n); }</span>
<span id="L1987"><span class="lineNum">    1987</span>              : </span>
<span id="L1988"><span class="lineNum">    1988</span>              :       const_local_iterator</span>
<span id="L1989"><span class="lineNum">    1989</span>              :       cend(size_type __n) const</span>
<span id="L1990"><span class="lineNum">    1990</span>              :       { return _M_h.cend(__n); }</span>
<span id="L1991"><span class="lineNum">    1991</span>              :       ///@}</span>
<span id="L1992"><span class="lineNum">    1992</span>              : </span>
<span id="L1993"><span class="lineNum">    1993</span>              :       // hash policy.</span>
<span id="L1994"><span class="lineNum">    1994</span>              : </span>
<span id="L1995"><span class="lineNum">    1995</span>              :       /// Returns the average number of elements per bucket.</span>
<span id="L1996"><span class="lineNum">    1996</span>              :       float</span>
<span id="L1997"><span class="lineNum">    1997</span>              :       load_factor() const noexcept</span>
<span id="L1998"><span class="lineNum">    1998</span>              :       { return _M_h.load_factor(); }</span>
<span id="L1999"><span class="lineNum">    1999</span>              : </span>
<span id="L2000"><span class="lineNum">    2000</span>              :       /// Returns a positive number that the %unordered_multimap tries to keep</span>
<span id="L2001"><span class="lineNum">    2001</span>              :       /// the load factor less than or equal to.</span>
<span id="L2002"><span class="lineNum">    2002</span>              :       float</span>
<span id="L2003"><span class="lineNum">    2003</span>              :       max_load_factor() const noexcept</span>
<span id="L2004"><span class="lineNum">    2004</span>              :       { return _M_h.max_load_factor(); }</span>
<span id="L2005"><span class="lineNum">    2005</span>              : </span>
<span id="L2006"><span class="lineNum">    2006</span>              :       /**</span>
<span id="L2007"><span class="lineNum">    2007</span>              :        *  @brief  Change the %unordered_multimap maximum load factor.</span>
<span id="L2008"><span class="lineNum">    2008</span>              :        *  @param  __z The new maximum load factor.</span>
<span id="L2009"><span class="lineNum">    2009</span>              :        */</span>
<span id="L2010"><span class="lineNum">    2010</span>              :       void</span>
<span id="L2011"><span class="lineNum">    2011</span>              :       max_load_factor(float __z)</span>
<span id="L2012"><span class="lineNum">    2012</span>              :       { _M_h.max_load_factor(__z); }</span>
<span id="L2013"><span class="lineNum">    2013</span>              : </span>
<span id="L2014"><span class="lineNum">    2014</span>              :       /**</span>
<span id="L2015"><span class="lineNum">    2015</span>              :        *  @brief  May rehash the %unordered_multimap.</span>
<span id="L2016"><span class="lineNum">    2016</span>              :        *  @param  __n The new number of buckets.</span>
<span id="L2017"><span class="lineNum">    2017</span>              :        *</span>
<span id="L2018"><span class="lineNum">    2018</span>              :        *  Rehash will occur only if the new number of buckets respect the</span>
<span id="L2019"><span class="lineNum">    2019</span>              :        *  %unordered_multimap maximum load factor.</span>
<span id="L2020"><span class="lineNum">    2020</span>              :        */</span>
<span id="L2021"><span class="lineNum">    2021</span>              :       void</span>
<span id="L2022"><span class="lineNum">    2022</span>              :       rehash(size_type __n)</span>
<span id="L2023"><span class="lineNum">    2023</span>              :       { _M_h.rehash(__n); }</span>
<span id="L2024"><span class="lineNum">    2024</span>              : </span>
<span id="L2025"><span class="lineNum">    2025</span>              :       /**</span>
<span id="L2026"><span class="lineNum">    2026</span>              :        *  @brief  Prepare the %unordered_multimap for a specified number of</span>
<span id="L2027"><span class="lineNum">    2027</span>              :        *          elements.</span>
<span id="L2028"><span class="lineNum">    2028</span>              :        *  @param  __n Number of elements required.</span>
<span id="L2029"><span class="lineNum">    2029</span>              :        *</span>
<span id="L2030"><span class="lineNum">    2030</span>              :        *  Same as rehash(ceil(n / max_load_factor())).</span>
<span id="L2031"><span class="lineNum">    2031</span>              :        */</span>
<span id="L2032"><span class="lineNum">    2032</span>              :       void</span>
<span id="L2033"><span class="lineNum">    2033</span>              :       reserve(size_type __n)</span>
<span id="L2034"><span class="lineNum">    2034</span>              :       { _M_h.reserve(__n); }</span>
<span id="L2035"><span class="lineNum">    2035</span>              : </span>
<span id="L2036"><span class="lineNum">    2036</span>              :       template&lt;typename _Key1, typename _Tp1, typename _Hash1, typename _Pred1,</span>
<span id="L2037"><span class="lineNum">    2037</span>              :                typename _Alloc1&gt;</span>
<span id="L2038"><span class="lineNum">    2038</span>              :         friend bool</span>
<span id="L2039"><span class="lineNum">    2039</span>              :         operator==(const unordered_multimap&lt;_Key1, _Tp1,</span>
<span id="L2040"><span class="lineNum">    2040</span>              :                                             _Hash1, _Pred1, _Alloc1&gt;&amp;,</span>
<span id="L2041"><span class="lineNum">    2041</span>              :                    const unordered_multimap&lt;_Key1, _Tp1,</span>
<span id="L2042"><span class="lineNum">    2042</span>              :                                             _Hash1, _Pred1, _Alloc1&gt;&amp;);</span>
<span id="L2043"><span class="lineNum">    2043</span>              :     };</span>
<span id="L2044"><span class="lineNum">    2044</span>              : </span>
<span id="L2045"><span class="lineNum">    2045</span>              : #if __cpp_deduction_guides &gt;= 201606</span>
<span id="L2046"><span class="lineNum">    2046</span>              : </span>
<span id="L2047"><span class="lineNum">    2047</span>              :   template&lt;typename _InputIterator,</span>
<span id="L2048"><span class="lineNum">    2048</span>              :            typename _Hash = hash&lt;__iter_key_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L2049"><span class="lineNum">    2049</span>              :            typename _Pred = equal_to&lt;__iter_key_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L2050"><span class="lineNum">    2050</span>              :            typename _Allocator = allocator&lt;__iter_to_alloc_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L2051"><span class="lineNum">    2051</span>              :            typename = _RequireInputIter&lt;_InputIterator&gt;,</span>
<span id="L2052"><span class="lineNum">    2052</span>              :            typename = _RequireNotAllocatorOrIntegral&lt;_Hash&gt;,</span>
<span id="L2053"><span class="lineNum">    2053</span>              :            typename = _RequireNotAllocator&lt;_Pred&gt;,</span>
<span id="L2054"><span class="lineNum">    2054</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L2055"><span class="lineNum">    2055</span>              :     unordered_multimap(_InputIterator, _InputIterator,</span>
<span id="L2056"><span class="lineNum">    2056</span>              :                        unordered_multimap&lt;int, int&gt;::size_type = {},</span>
<span id="L2057"><span class="lineNum">    2057</span>              :                        _Hash = _Hash(), _Pred = _Pred(),</span>
<span id="L2058"><span class="lineNum">    2058</span>              :                        _Allocator = _Allocator())</span>
<span id="L2059"><span class="lineNum">    2059</span>              :     -&gt; unordered_multimap&lt;__iter_key_t&lt;_InputIterator&gt;,</span>
<span id="L2060"><span class="lineNum">    2060</span>              :                           __iter_val_t&lt;_InputIterator&gt;, _Hash, _Pred,</span>
<span id="L2061"><span class="lineNum">    2061</span>              :                           _Allocator&gt;;</span>
<span id="L2062"><span class="lineNum">    2062</span>              : </span>
<span id="L2063"><span class="lineNum">    2063</span>              :   template&lt;typename _Key, typename _Tp, typename _Hash = hash&lt;_Key&gt;,</span>
<span id="L2064"><span class="lineNum">    2064</span>              :            typename _Pred = equal_to&lt;_Key&gt;,</span>
<span id="L2065"><span class="lineNum">    2065</span>              :            typename _Allocator = allocator&lt;pair&lt;const _Key, _Tp&gt;&gt;,</span>
<span id="L2066"><span class="lineNum">    2066</span>              :            typename = _RequireNotAllocatorOrIntegral&lt;_Hash&gt;,</span>
<span id="L2067"><span class="lineNum">    2067</span>              :            typename = _RequireNotAllocator&lt;_Pred&gt;,</span>
<span id="L2068"><span class="lineNum">    2068</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L2069"><span class="lineNum">    2069</span>              :     unordered_multimap(initializer_list&lt;pair&lt;_Key, _Tp&gt;&gt;,</span>
<span id="L2070"><span class="lineNum">    2070</span>              :                        unordered_multimap&lt;int, int&gt;::size_type = {},</span>
<span id="L2071"><span class="lineNum">    2071</span>              :                        _Hash = _Hash(), _Pred = _Pred(),</span>
<span id="L2072"><span class="lineNum">    2072</span>              :                        _Allocator = _Allocator())</span>
<span id="L2073"><span class="lineNum">    2073</span>              :     -&gt; unordered_multimap&lt;_Key, _Tp, _Hash, _Pred, _Allocator&gt;;</span>
<span id="L2074"><span class="lineNum">    2074</span>              : </span>
<span id="L2075"><span class="lineNum">    2075</span>              :   template&lt;typename _InputIterator, typename _Allocator,</span>
<span id="L2076"><span class="lineNum">    2076</span>              :            typename = _RequireInputIter&lt;_InputIterator&gt;,</span>
<span id="L2077"><span class="lineNum">    2077</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L2078"><span class="lineNum">    2078</span>              :     unordered_multimap(_InputIterator, _InputIterator,</span>
<span id="L2079"><span class="lineNum">    2079</span>              :                        unordered_multimap&lt;int, int&gt;::size_type, _Allocator)</span>
<span id="L2080"><span class="lineNum">    2080</span>              :     -&gt; unordered_multimap&lt;__iter_key_t&lt;_InputIterator&gt;,</span>
<span id="L2081"><span class="lineNum">    2081</span>              :                           __iter_val_t&lt;_InputIterator&gt;,</span>
<span id="L2082"><span class="lineNum">    2082</span>              :                           hash&lt;__iter_key_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L2083"><span class="lineNum">    2083</span>              :                           equal_to&lt;__iter_key_t&lt;_InputIterator&gt;&gt;, _Allocator&gt;;</span>
<span id="L2084"><span class="lineNum">    2084</span>              : </span>
<span id="L2085"><span class="lineNum">    2085</span>              :   template&lt;typename _InputIterator, typename _Allocator,</span>
<span id="L2086"><span class="lineNum">    2086</span>              :            typename = _RequireInputIter&lt;_InputIterator&gt;,</span>
<span id="L2087"><span class="lineNum">    2087</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L2088"><span class="lineNum">    2088</span>              :     unordered_multimap(_InputIterator, _InputIterator, _Allocator)</span>
<span id="L2089"><span class="lineNum">    2089</span>              :     -&gt; unordered_multimap&lt;__iter_key_t&lt;_InputIterator&gt;,</span>
<span id="L2090"><span class="lineNum">    2090</span>              :                           __iter_val_t&lt;_InputIterator&gt;,</span>
<span id="L2091"><span class="lineNum">    2091</span>              :                           hash&lt;__iter_key_t&lt;_InputIterator&gt;&gt;,</span>
<span id="L2092"><span class="lineNum">    2092</span>              :                           equal_to&lt;__iter_key_t&lt;_InputIterator&gt;&gt;, _Allocator&gt;;</span>
<span id="L2093"><span class="lineNum">    2093</span>              : </span>
<span id="L2094"><span class="lineNum">    2094</span>              :   template&lt;typename _InputIterator, typename _Hash, typename _Allocator,</span>
<span id="L2095"><span class="lineNum">    2095</span>              :            typename = _RequireInputIter&lt;_InputIterator&gt;,</span>
<span id="L2096"><span class="lineNum">    2096</span>              :            typename = _RequireNotAllocatorOrIntegral&lt;_Hash&gt;,</span>
<span id="L2097"><span class="lineNum">    2097</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L2098"><span class="lineNum">    2098</span>              :     unordered_multimap(_InputIterator, _InputIterator,</span>
<span id="L2099"><span class="lineNum">    2099</span>              :                        unordered_multimap&lt;int, int&gt;::size_type, _Hash,</span>
<span id="L2100"><span class="lineNum">    2100</span>              :                        _Allocator)</span>
<span id="L2101"><span class="lineNum">    2101</span>              :     -&gt; unordered_multimap&lt;__iter_key_t&lt;_InputIterator&gt;,</span>
<span id="L2102"><span class="lineNum">    2102</span>              :                           __iter_val_t&lt;_InputIterator&gt;, _Hash,</span>
<span id="L2103"><span class="lineNum">    2103</span>              :                           equal_to&lt;__iter_key_t&lt;_InputIterator&gt;&gt;, _Allocator&gt;;</span>
<span id="L2104"><span class="lineNum">    2104</span>              : </span>
<span id="L2105"><span class="lineNum">    2105</span>              :   template&lt;typename _Key, typename _Tp, typename _Allocator,</span>
<span id="L2106"><span class="lineNum">    2106</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L2107"><span class="lineNum">    2107</span>              :     unordered_multimap(initializer_list&lt;pair&lt;_Key, _Tp&gt;&gt;,</span>
<span id="L2108"><span class="lineNum">    2108</span>              :                        unordered_multimap&lt;int, int&gt;::size_type,</span>
<span id="L2109"><span class="lineNum">    2109</span>              :                        _Allocator)</span>
<span id="L2110"><span class="lineNum">    2110</span>              :     -&gt; unordered_multimap&lt;_Key, _Tp, hash&lt;_Key&gt;, equal_to&lt;_Key&gt;, _Allocator&gt;;</span>
<span id="L2111"><span class="lineNum">    2111</span>              : </span>
<span id="L2112"><span class="lineNum">    2112</span>              :   template&lt;typename _Key, typename _Tp, typename _Allocator,</span>
<span id="L2113"><span class="lineNum">    2113</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L2114"><span class="lineNum">    2114</span>              :     unordered_multimap(initializer_list&lt;pair&lt;_Key, _Tp&gt;&gt;, _Allocator)</span>
<span id="L2115"><span class="lineNum">    2115</span>              :     -&gt; unordered_multimap&lt;_Key, _Tp, hash&lt;_Key&gt;, equal_to&lt;_Key&gt;, _Allocator&gt;;</span>
<span id="L2116"><span class="lineNum">    2116</span>              : </span>
<span id="L2117"><span class="lineNum">    2117</span>              :   template&lt;typename _Key, typename _Tp, typename _Hash, typename _Allocator,</span>
<span id="L2118"><span class="lineNum">    2118</span>              :            typename = _RequireNotAllocatorOrIntegral&lt;_Hash&gt;,</span>
<span id="L2119"><span class="lineNum">    2119</span>              :            typename = _RequireAllocator&lt;_Allocator&gt;&gt;</span>
<span id="L2120"><span class="lineNum">    2120</span>              :     unordered_multimap(initializer_list&lt;pair&lt;_Key, _Tp&gt;&gt;,</span>
<span id="L2121"><span class="lineNum">    2121</span>              :                        unordered_multimap&lt;int, int&gt;::size_type,</span>
<span id="L2122"><span class="lineNum">    2122</span>              :                        _Hash, _Allocator)</span>
<span id="L2123"><span class="lineNum">    2123</span>              :     -&gt; unordered_multimap&lt;_Key, _Tp, _Hash, equal_to&lt;_Key&gt;, _Allocator&gt;;</span>
<span id="L2124"><span class="lineNum">    2124</span>              : </span>
<span id="L2125"><span class="lineNum">    2125</span>              : #endif</span>
<span id="L2126"><span class="lineNum">    2126</span>              : </span>
<span id="L2127"><span class="lineNum">    2127</span>              :   template&lt;class _Key, class _Tp, class _Hash, class _Pred, class _Alloc&gt;</span>
<span id="L2128"><span class="lineNum">    2128</span>              :     inline void</span>
<span id="L2129"><span class="lineNum">    2129</span>              :     swap(unordered_map&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __x,</span>
<span id="L2130"><span class="lineNum">    2130</span>              :          unordered_map&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __y)</span>
<span id="L2131"><span class="lineNum">    2131</span>              :     noexcept(noexcept(__x.swap(__y)))</span>
<span id="L2132"><span class="lineNum">    2132</span>              :     { __x.swap(__y); }</span>
<span id="L2133"><span class="lineNum">    2133</span>              : </span>
<span id="L2134"><span class="lineNum">    2134</span>              :   template&lt;class _Key, class _Tp, class _Hash, class _Pred, class _Alloc&gt;</span>
<span id="L2135"><span class="lineNum">    2135</span>              :     inline void</span>
<span id="L2136"><span class="lineNum">    2136</span>              :     swap(unordered_multimap&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __x,</span>
<span id="L2137"><span class="lineNum">    2137</span>              :          unordered_multimap&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __y)</span>
<span id="L2138"><span class="lineNum">    2138</span>              :     noexcept(noexcept(__x.swap(__y)))</span>
<span id="L2139"><span class="lineNum">    2139</span>              :     { __x.swap(__y); }</span>
<span id="L2140"><span class="lineNum">    2140</span>              : </span>
<span id="L2141"><span class="lineNum">    2141</span>              :   template&lt;class _Key, class _Tp, class _Hash, class _Pred, class _Alloc&gt;</span>
<span id="L2142"><span class="lineNum">    2142</span>              :     inline bool</span>
<span id="L2143"><span class="lineNum">    2143</span>              :     operator==(const unordered_map&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __x,</span>
<span id="L2144"><span class="lineNum">    2144</span>              :                const unordered_map&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __y)</span>
<span id="L2145"><span class="lineNum">    2145</span>              :     { return __x._M_h._M_equal(__y._M_h); }</span>
<span id="L2146"><span class="lineNum">    2146</span>              : </span>
<span id="L2147"><span class="lineNum">    2147</span>              : #if __cpp_impl_three_way_comparison &lt; 201907L</span>
<span id="L2148"><span class="lineNum">    2148</span>              :   template&lt;class _Key, class _Tp, class _Hash, class _Pred, class _Alloc&gt;</span>
<span id="L2149"><span class="lineNum">    2149</span>              :     inline bool</span>
<span id="L2150"><span class="lineNum">    2150</span>              :     operator!=(const unordered_map&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __x,</span>
<span id="L2151"><span class="lineNum">    2151</span>              :                const unordered_map&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __y)</span>
<span id="L2152"><span class="lineNum">    2152</span>              :     { return !(__x == __y); }</span>
<span id="L2153"><span class="lineNum">    2153</span>              : #endif</span>
<span id="L2154"><span class="lineNum">    2154</span>              : </span>
<span id="L2155"><span class="lineNum">    2155</span>              :   template&lt;class _Key, class _Tp, class _Hash, class _Pred, class _Alloc&gt;</span>
<span id="L2156"><span class="lineNum">    2156</span>              :     inline bool</span>
<span id="L2157"><span class="lineNum">    2157</span>              :     operator==(const unordered_multimap&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __x,</span>
<span id="L2158"><span class="lineNum">    2158</span>              :                const unordered_multimap&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __y)</span>
<span id="L2159"><span class="lineNum">    2159</span>              :     { return __x._M_h._M_equal(__y._M_h); }</span>
<span id="L2160"><span class="lineNum">    2160</span>              : </span>
<span id="L2161"><span class="lineNum">    2161</span>              : #if __cpp_impl_three_way_comparison &lt; 201907L</span>
<span id="L2162"><span class="lineNum">    2162</span>              :   template&lt;class _Key, class _Tp, class _Hash, class _Pred, class _Alloc&gt;</span>
<span id="L2163"><span class="lineNum">    2163</span>              :     inline bool</span>
<span id="L2164"><span class="lineNum">    2164</span>              :     operator!=(const unordered_multimap&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __x,</span>
<span id="L2165"><span class="lineNum">    2165</span>              :                const unordered_multimap&lt;_Key, _Tp, _Hash, _Pred, _Alloc&gt;&amp; __y)</span>
<span id="L2166"><span class="lineNum">    2166</span>              :     { return !(__x == __y); }</span>
<span id="L2167"><span class="lineNum">    2167</span>              : #endif</span>
<span id="L2168"><span class="lineNum">    2168</span>              : </span>
<span id="L2169"><span class="lineNum">    2169</span>              : _GLIBCXX_END_NAMESPACE_CONTAINER</span>
<span id="L2170"><span class="lineNum">    2170</span>              : </span>
<span id="L2171"><span class="lineNum">    2171</span>              : #if __cplusplus &gt; 201402L</span>
<span id="L2172"><span class="lineNum">    2172</span>              :   // Allow std::unordered_map access to internals of compatible maps.</span>
<span id="L2173"><span class="lineNum">    2173</span>              :   template&lt;typename _Key, typename _Val, typename _Hash1, typename _Eq1,</span>
<span id="L2174"><span class="lineNum">    2174</span>              :            typename _Alloc, typename _Hash2, typename _Eq2&gt;</span>
<span id="L2175"><span class="lineNum">    2175</span>              :     struct _Hash_merge_helper&lt;</span>
<span id="L2176"><span class="lineNum">    2176</span>              :       _GLIBCXX_STD_C::unordered_map&lt;_Key, _Val, _Hash1, _Eq1, _Alloc&gt;,</span>
<span id="L2177"><span class="lineNum">    2177</span>              :       _Hash2, _Eq2&gt;</span>
<span id="L2178"><span class="lineNum">    2178</span>              :     {</span>
<span id="L2179"><span class="lineNum">    2179</span>              :     private:</span>
<span id="L2180"><span class="lineNum">    2180</span>              :       template&lt;typename... _Tp&gt;</span>
<span id="L2181"><span class="lineNum">    2181</span>              :         using unordered_map = _GLIBCXX_STD_C::unordered_map&lt;_Tp...&gt;;</span>
<span id="L2182"><span class="lineNum">    2182</span>              :       template&lt;typename... _Tp&gt;</span>
<span id="L2183"><span class="lineNum">    2183</span>              :         using unordered_multimap = _GLIBCXX_STD_C::unordered_multimap&lt;_Tp...&gt;;</span>
<span id="L2184"><span class="lineNum">    2184</span>              : </span>
<span id="L2185"><span class="lineNum">    2185</span>              :       friend unordered_map&lt;_Key, _Val, _Hash1, _Eq1, _Alloc&gt;;</span>
<span id="L2186"><span class="lineNum">    2186</span>              : </span>
<span id="L2187"><span class="lineNum">    2187</span>              :       static auto&amp;</span>
<span id="L2188"><span class="lineNum">    2188</span>              :       _S_get_table(unordered_map&lt;_Key, _Val, _Hash2, _Eq2, _Alloc&gt;&amp; __map)</span>
<span id="L2189"><span class="lineNum">    2189</span>              :       { return __map._M_h; }</span>
<span id="L2190"><span class="lineNum">    2190</span>              : </span>
<span id="L2191"><span class="lineNum">    2191</span>              :       static auto&amp;</span>
<span id="L2192"><span class="lineNum">    2192</span>              :       _S_get_table(unordered_multimap&lt;_Key, _Val, _Hash2, _Eq2, _Alloc&gt;&amp; __map)</span>
<span id="L2193"><span class="lineNum">    2193</span>              :       { return __map._M_h; }</span>
<span id="L2194"><span class="lineNum">    2194</span>              :     };</span>
<span id="L2195"><span class="lineNum">    2195</span>              : </span>
<span id="L2196"><span class="lineNum">    2196</span>              :   // Allow std::unordered_multimap access to internals of compatible maps.</span>
<span id="L2197"><span class="lineNum">    2197</span>              :   template&lt;typename _Key, typename _Val, typename _Hash1, typename _Eq1,</span>
<span id="L2198"><span class="lineNum">    2198</span>              :            typename _Alloc, typename _Hash2, typename _Eq2&gt;</span>
<span id="L2199"><span class="lineNum">    2199</span>              :     struct _Hash_merge_helper&lt;</span>
<span id="L2200"><span class="lineNum">    2200</span>              :       _GLIBCXX_STD_C::unordered_multimap&lt;_Key, _Val, _Hash1, _Eq1, _Alloc&gt;,</span>
<span id="L2201"><span class="lineNum">    2201</span>              :       _Hash2, _Eq2&gt;</span>
<span id="L2202"><span class="lineNum">    2202</span>              :     {</span>
<span id="L2203"><span class="lineNum">    2203</span>              :     private:</span>
<span id="L2204"><span class="lineNum">    2204</span>              :       template&lt;typename... _Tp&gt;</span>
<span id="L2205"><span class="lineNum">    2205</span>              :         using unordered_map = _GLIBCXX_STD_C::unordered_map&lt;_Tp...&gt;;</span>
<span id="L2206"><span class="lineNum">    2206</span>              :       template&lt;typename... _Tp&gt;</span>
<span id="L2207"><span class="lineNum">    2207</span>              :         using unordered_multimap = _GLIBCXX_STD_C::unordered_multimap&lt;_Tp...&gt;;</span>
<span id="L2208"><span class="lineNum">    2208</span>              : </span>
<span id="L2209"><span class="lineNum">    2209</span>              :       friend unordered_multimap&lt;_Key, _Val, _Hash1, _Eq1, _Alloc&gt;;</span>
<span id="L2210"><span class="lineNum">    2210</span>              : </span>
<span id="L2211"><span class="lineNum">    2211</span>              :       static auto&amp;</span>
<span id="L2212"><span class="lineNum">    2212</span>              :       _S_get_table(unordered_map&lt;_Key, _Val, _Hash2, _Eq2, _Alloc&gt;&amp; __map)</span>
<span id="L2213"><span class="lineNum">    2213</span>              :       { return __map._M_h; }</span>
<span id="L2214"><span class="lineNum">    2214</span>              : </span>
<span id="L2215"><span class="lineNum">    2215</span>              :       static auto&amp;</span>
<span id="L2216"><span class="lineNum">    2216</span>              :       _S_get_table(unordered_multimap&lt;_Key, _Val, _Hash2, _Eq2, _Alloc&gt;&amp; __map)</span>
<span id="L2217"><span class="lineNum">    2217</span>              :       { return __map._M_h; }</span>
<span id="L2218"><span class="lineNum">    2218</span>              :     };</span>
<span id="L2219"><span class="lineNum">    2219</span>              : #endif // C++17</span>
<span id="L2220"><span class="lineNum">    2220</span>              : </span>
<span id="L2221"><span class="lineNum">    2221</span>              : _GLIBCXX_END_NAMESPACE_VERSION</span>
<span id="L2222"><span class="lineNum">    2222</span>              : } // namespace std</span>
<span id="L2223"><span class="lineNum">    2223</span>              : </span>
<span id="L2224"><span class="lineNum">    2224</span>              : #endif /* _UNORDERED_MAP_H */</span>
        </pre>
              </td>
            </tr>
          </table>
          <br>

          <table width="100%" border=0 cellspacing=0 cellpadding=0>
            <tr><td class="ruler"><img src="../../glass.png" width=3 height=3 alt=""></td></tr>
            <tr><td class="versionInfo">Generated by: <a href="https://github.com//linux-test-project/lcov" target="_parent">LCOV version 2.0-1</a></td></tr>
          </table>
          <br>

</body>
</html>
